@kody-ade/kody-engine 0.1.7 → 0.2.0

package/dist/bin/kody2.js

@@ -0,0 +1,2512 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+var LITELLM_DEFAULT_PORT = 4e3;
+var LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
+function parseProviderModel(s) {
+  const slash = s.indexOf("/");
+  if (slash <= 0 || slash === s.length - 1) {
+    throw new Error(
+      `Invalid model spec '${s}' \u2014 expected 'provider/model' (e.g. 'minimax/MiniMax-M2.7-highspeed')`
+    );
+  }
+  return { provider: s.slice(0, slash), model: s.slice(slash + 1) };
+}
+function providerApiKeyEnvVar(provider) {
+  if (provider === "anthropic" || provider === "claude") return "ANTHROPIC_API_KEY";
+  return `${provider.toUpperCase()}_API_KEY`;
+}
+function needsLitellmProxy(model) {
+  return model.provider !== "claude" && model.provider !== "anthropic";
+}
+function loadConfig(projectDir = process.cwd()) {
+  const configPath = path.join(projectDir, "kody.config.json");
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`kody.config.json not found at ${configPath}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`kody.config.json is invalid JSON: ${msg}`);
+  }
+  const quality = raw.quality ?? {};
+  const git3 = raw.git ?? {};
+  const github = raw.github ?? {};
+  const agent = raw.agent ?? {};
+  if (!agent.model || typeof agent.model !== "string") {
+    throw new Error(`kody.config.json: agent.model is required (e.g. "minimax/MiniMax-M2.7-highspeed")`);
+  }
+  if (!github.owner || !github.repo) {
+    throw new Error(`kody.config.json: github.owner and github.repo are required`);
+  }
+  return {
+    quality: {
+      typecheck: typeof quality.typecheck === "string" ? quality.typecheck : "",
+      lint: typeof quality.lint === "string" ? quality.lint : "",
+      testUnit: typeof quality.testUnit === "string" ? quality.testUnit : ""
+    },
+    git: {
+      defaultBranch: typeof git3.defaultBranch === "string" ? git3.defaultBranch : "main"
+    },
+    github: {
+      owner: String(github.owner),
+      repo: String(github.repo)
+    },
+    agent: {
+      model: String(agent.model)
+    },
+    issueContext: parseIssueContext(raw.issueContext),
+    testRequirements: parseTestRequirements(raw.testRequirements)
+  };
+}
+function parseIssueContext(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  if (typeof r.commentLimit === "number" && r.commentLimit > 0) out.commentLimit = Math.floor(r.commentLimit);
+  if (typeof r.commentMaxBytes === "number" && r.commentMaxBytes > 0) out.commentMaxBytes = Math.floor(r.commentMaxBytes);
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function parseTestRequirements(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const item of raw) {
+    if (item && typeof item === "object" && typeof item.pattern === "string" && typeof item.requireSibling === "string") {
+      out.push({
+        pattern: item.pattern,
+        requireSibling: item.requireSibling
+      });
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function getAnthropicApiKeyOrDummy() {
+  return process.env.ANTHROPIC_API_KEY || `sk-ant-api03-${"0".repeat(64)}`;
+}
+
+// src/executor.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
+
+// src/profile.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var VALID_INPUT_TYPES = /* @__PURE__ */ new Set(["int", "string", "bool", "enum"]);
+var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
+var ProfileError = class extends Error {
+  constructor(profilePath, message) {
+    super(`Invalid profile at ${profilePath}:
+  ${message}`);
+    this.profilePath = profilePath;
+    this.name = "ProfileError";
+  }
+  profilePath;
+};
+function loadProfile(profilePath) {
+  if (!fs2.existsSync(profilePath)) {
+    throw new ProfileError(profilePath, "file not found");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs2.readFileSync(profilePath, "utf-8"));
+  } catch (err) {
+    throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!raw || typeof raw !== "object") {
+    throw new ProfileError(profilePath, "profile must be a JSON object");
+  }
+  const r = raw;
+  const profile = {
+    name: requireString(profilePath, r, "name"),
+    describe: typeof r.describe === "string" ? r.describe : "",
+    inputs: parseInputs(profilePath, r.inputs),
+    claudeCode: parseClaudeCode(profilePath, r.claudeCode),
+    cliTools: parseCliTools(profilePath, r.cliTools),
+    scripts: parseScripts(profilePath, r.scripts),
+    outputContract: r.outputContract,
+    dir: path2.dirname(profilePath)
+  };
+  return profile;
+}
+function validateScriptReferences(profile, registeredScripts) {
+  const missing = [];
+  for (const e of [...profile.scripts.preflight, ...profile.scripts.postflight]) {
+    if (!registeredScripts.has(e.script)) missing.push(e.script);
+  }
+  return missing;
+}
+function requireString(p, r, key) {
+  const v = r[key];
+  if (typeof v !== "string" || v.length === 0) {
+    throw new ProfileError(p, `"${key}" must be a non-empty string`);
+  }
+  return v;
+}
+function parseInputs(p, raw) {
+  if (!Array.isArray(raw)) throw new ProfileError(p, `"inputs" must be an array`);
+  const out = [];
+  for (const [i, item] of raw.entries()) {
+    if (!item || typeof item !== "object") {
+      throw new ProfileError(p, `inputs[${i}] must be an object`);
+    }
+    const r = item;
+    const name = requireString(p, r, "name");
+    const flag = requireString(p, r, "flag");
+    const type = requireString(p, r, "type");
+    if (!VALID_INPUT_TYPES.has(type)) {
+      throw new ProfileError(p, `inputs[${i}].type must be one of int|string|bool|enum`);
+    }
+    const spec = {
+      name,
+      flag,
+      type,
+      describe: typeof r.describe === "string" ? r.describe : ""
+    };
+    if (type === "enum") {
+      if (!Array.isArray(r.values) || r.values.length === 0) {
+        throw new ProfileError(p, `inputs[${i}] (enum) requires non-empty "values" array`);
+      }
+      spec.values = r.values;
+    }
+    if (typeof r.required === "boolean") spec.required = r.required;
+    if (r.requiredWhen && typeof r.requiredWhen === "object") {
+      spec.requiredWhen = r.requiredWhen;
+    }
+    out.push(spec);
+  }
+  return out;
+}
+function parseClaudeCode(p, raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new ProfileError(p, `"claudeCode" must be an object`);
+  }
+  const r = raw;
+  const permissionMode = typeof r.permissionMode === "string" ? r.permissionMode : "acceptEdits";
+  if (!VALID_PERMISSION_MODES.has(permissionMode)) {
+    throw new ProfileError(p, `claudeCode.permissionMode must be one of default|acceptEdits|plan|bypassPermissions`);
+  }
+  const tools = Array.isArray(r.tools) ? r.tools : [];
+  if (tools.length === 0) {
+    throw new ProfileError(p, `claudeCode.tools must declare at least one SDK tool`);
+  }
+  const hooksRaw = r.hooks ?? {};
+  const hooks = {
+    PreToolUse: Array.isArray(hooksRaw.PreToolUse) ? hooksRaw.PreToolUse : [],
+    PostToolUse: Array.isArray(hooksRaw.PostToolUse) ? hooksRaw.PostToolUse : [],
+    Stop: Array.isArray(hooksRaw.Stop) ? hooksRaw.Stop : []
+  };
+  return {
+    model: typeof r.model === "string" ? r.model : "inherit",
+    permissionMode,
+    maxTurns: typeof r.maxTurns === "number" ? r.maxTurns : null,
+    systemPromptAppend: typeof r.systemPromptAppend === "string" ? r.systemPromptAppend : null,
+    tools,
+    hooks,
+    skills: Array.isArray(r.skills) ? r.skills : [],
+    commands: Array.isArray(r.commands) ? r.commands : [],
+    subagents: Array.isArray(r.subagents) ? r.subagents : [],
+    plugins: Array.isArray(r.plugins) ? r.plugins : [],
+    mcpServers: Array.isArray(r.mcpServers) ? r.mcpServers : []
+  };
+}
+function parseCliTools(p, raw) {
+  if (raw === void 0 || raw === null) return [];
+  if (!Array.isArray(raw)) throw new ProfileError(p, `"cliTools" must be an array or absent`);
+  const out = [];
+  for (const [i, item] of raw.entries()) {
+    if (!item || typeof item !== "object") {
+      throw new ProfileError(p, `cliTools[${i}] must be an object`);
+    }
+    const r = item;
+    const install = r.install;
+    if (!install || typeof install !== "object") {
+      throw new ProfileError(p, `cliTools[${i}].install must be an object`);
+    }
+    out.push({
+      name: requireString(p, r, "name"),
+      install: {
+        required: Boolean(install.required),
+        checkCommand: requireString(p, install, "checkCommand"),
+        installCommand: typeof install.installCommand === "string" ? install.installCommand : void 0
+      },
+      verify: requireString(p, r, "verify"),
+      usage: typeof r.usage === "string" ? r.usage : "",
+      allowedUses: Array.isArray(r.allowedUses) ? r.allowedUses : []
+    });
+  }
+  return out;
+}
+function parseScripts(p, raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new ProfileError(p, `"scripts" must be an object with preflight and postflight arrays`);
+  }
+  const r = raw;
+  return {
+    preflight: parseScriptList(p, "preflight", r.preflight),
+    postflight: parseScriptList(p, "postflight", r.postflight)
+  };
+}
+function parseScriptList(p, key, raw) {
+  if (!Array.isArray(raw)) {
+    throw new ProfileError(p, `scripts.${key} must be an array`);
+  }
+  const out = [];
+  for (const [i, item] of raw.entries()) {
+    if (!item || typeof item !== "object") {
+      throw new ProfileError(p, `scripts.${key}[${i}] must be an object like { script, runWhen? }`);
+    }
+    const r = item;
+    const script = requireString(p, r, "script");
+    const entry = { script };
+    if (r.runWhen && typeof r.runWhen === "object") {
+      entry.runWhen = r.runWhen;
+    }
+    out.push(entry);
+  }
+  return out;
+}
+
+// src/issue.ts
+import { execFileSync } from "child_process";
+var API_TIMEOUT_MS = 3e4;
+function ghToken() {
+  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+}
+function gh(args, options) {
+  const token = ghToken();
+  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+  return execFileSync("gh", args, {
+    encoding: "utf-8",
+    timeout: API_TIMEOUT_MS,
+    cwd: options?.cwd,
+    env,
+    input: options?.input,
+    stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"]
+  }).trim();
+}
+function getIssue(issueNumber, cwd) {
+  const output = gh(
+    ["issue", "view", String(issueNumber), "--json", "number,title,body,comments"],
+    { cwd }
+  );
+  const parsed = JSON.parse(output);
+  if (typeof parsed?.title !== "string") {
+    throw new Error(`Issue #${issueNumber}: unexpected response shape`);
+  }
+  return {
+    number: parsed.number ?? issueNumber,
+    title: parsed.title,
+    body: parsed.body ?? "",
+    comments: (parsed.comments ?? []).map((c) => ({
+      body: c.body ?? "",
+      author: c.author?.login ?? "unknown",
+      createdAt: c.createdAt ?? ""
+    }))
+  };
+}
+function postIssueComment(issueNumber, body, cwd) {
+  try {
+    gh(
+      ["issue", "comment", String(issueNumber), "--body-file", "-"],
+      { input: body, cwd }
+    );
+  } catch (err) {
+    process.stderr.write(`[kody2] failed to post comment on #${issueNumber}: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function truncate(s, maxBytes) {
+  if (s.length <= maxBytes) return s;
+  return s.slice(0, maxBytes) + `\u2026 (+${s.length - maxBytes} chars)`;
+}
+function getPr(prNumber, cwd) {
+  const output = gh(
+    ["pr", "view", String(prNumber), "--json", "number,title,body,headRefName,baseRefName,state"],
+    { cwd }
+  );
+  const parsed = JSON.parse(output);
+  if (typeof parsed?.title !== "string") {
+    throw new Error(`PR #${prNumber}: unexpected response shape`);
+  }
+  return {
+    number: parsed.number ?? prNumber,
+    title: parsed.title,
+    body: parsed.body ?? "",
+    headRefName: String(parsed.headRefName ?? ""),
+    baseRefName: String(parsed.baseRefName ?? ""),
+    state: String(parsed.state ?? "")
+  };
+}
+function getPrDiff(prNumber, cwd) {
+  try {
+    return gh(["pr", "diff", String(prNumber)], { cwd });
+  } catch (err) {
+    process.stderr.write(`[kody2] failed to fetch diff for PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}
+`);
+    return "";
+  }
+}
+function getPrReviews(prNumber, cwd) {
+  try {
+    const output = gh(
+      ["pr", "view", String(prNumber), "--json", "reviews"],
+      { cwd }
+    );
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed?.reviews)) return [];
+    return parsed.reviews.map((r) => ({
+      body: r.body ?? "",
+      state: r.state ?? "",
+      author: r.author?.login ?? "unknown",
+      submittedAt: r.submittedAt ?? ""
+    }));
+  } catch {
+    return [];
+  }
+}
+function getPrComments(prNumber, cwd) {
+  try {
+    const output = gh(["pr", "view", String(prNumber), "--json", "comments"], { cwd });
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed?.comments)) return [];
+    return parsed.comments.map((c) => ({
+      body: c.body ?? "",
+      author: c.author?.login ?? "unknown",
+      createdAt: c.createdAt ?? ""
+    })).filter((c) => c.body.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+var KODY_COMMENT_PREFIXES = ["\u2699\uFE0F kody2", "\u2705 kody2", "\u26A0\uFE0F kody2", "\u2139\uFE0F kody2", "\u2192 kody2"];
+function getPrLatestReviewBody(prNumber, cwd) {
+  const reviews = getPrReviews(prNumber, cwd).filter((r) => r.body.trim().length > 0).map((r) => ({ body: r.body, at: r.submittedAt }));
+  const comments = getPrComments(prNumber, cwd).filter((c) => !KODY_COMMENT_PREFIXES.some((p) => c.body.startsWith(p))).map((c) => ({ body: c.body, at: c.createdAt }));
+  const all = [...reviews, ...comments].sort((a, b) => (b.at || "").localeCompare(a.at || ""));
+  if (all.length > 0) return all[0].body;
+  const pr = getPr(prNumber, cwd);
+  return pr.body;
+}
+function postPrReviewComment(prNumber, body, cwd) {
+  try {
+    gh(["pr", "comment", String(prNumber), "--body-file", "-"], { input: body, cwd });
+  } catch (err) {
+    process.stderr.write(`[kody2] failed to post review comment on PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+
+// src/branch.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var UncommittedChangesError = class extends Error {
+  constructor(branch) {
+    super(`Uncommitted changes on branch '${branch}' \u2014 refusing to run to protect work in progress`);
+    this.branch = branch;
+    this.name = "UncommittedChangesError";
+  }
+  branch;
+};
+function git(args, cwd) {
+  return execFileSync2("git", args, {
+    encoding: "utf-8",
+    timeout: 3e4,
+    cwd,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+    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 slug ? `${issueNumber}-${slug}` : `${issueNumber}`;
+}
+function getCurrentBranch(cwd) {
+  return git(["branch", "--show-current"], cwd);
+}
+function hasUncommittedChanges(cwd) {
+  return git(["status", "--porcelain", "--untracked-files=no"], cwd).length > 0;
+}
+function checkoutPrBranch(prNumber, cwd) {
+  const env = {
+    ...process.env,
+    HUSKY: "0",
+    SKIP_HOOKS: "1",
+    GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
+  };
+  execFileSync2("gh", ["pr", "checkout", String(prNumber)], {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 6e4
+  });
+  return getCurrentBranch(cwd);
+}
+function mergeBase(baseBranch, cwd) {
+  try {
+    git(["fetch", "origin", baseBranch], cwd);
+  } catch {
+    return "error";
+  }
+  try {
+    git(["merge", `origin/${baseBranch}`, "--no-edit", "--no-ff"], cwd);
+    return "clean";
+  } catch {
+    try {
+      const unmerged = git(["diff", "--name-only", "--diff-filter=U"], cwd);
+      if (unmerged.length > 0) return "conflict";
+    } catch {
+    }
+    try {
+      git(["merge", "--abort"], cwd);
+    } catch {
+    }
+    return "error";
+  }
+}
+function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
+  const branchName = deriveBranchName(issueNumber, title);
+  const current = getCurrentBranch(cwd);
+  if (current === branchName) {
+    if (hasUncommittedChanges(cwd)) throw new UncommittedChangesError(branchName);
+    return { branch: branchName, created: false };
+  }
+  if (hasUncommittedChanges(cwd)) throw new UncommittedChangesError(current || "(detached)");
+  try {
+    git(["fetch", "origin"], cwd);
+  } catch {
+  }
+  try {
+    git(["rev-parse", "--verify", `origin/${branchName}`], cwd);
+    git(["checkout", branchName], cwd);
+    try {
+      git(["pull", "origin", branchName], cwd);
+    } catch {
+    }
+    return { branch: branchName, created: false };
+  } catch {
+  }
+  try {
+    git(["rev-parse", "--verify", branchName], cwd);
+    git(["checkout", branchName], cwd);
+    return { branch: branchName, created: false };
+  } catch {
+  }
+  try {
+    git(["checkout", "-b", branchName, `origin/${defaultBranch}`], cwd);
+  } catch {
+    git(["checkout", "-b", branchName], cwd);
+  }
+  return { branch: branchName, created: true };
+}
+
+// src/gha.ts
+import * as fs3 from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+function getRunUrl() {
+  const server = process.env.GITHUB_SERVER_URL;
+  const repo = process.env.GITHUB_REPOSITORY;
+  const runId = process.env.GITHUB_RUN_ID;
+  if (!server || !repo || !runId) return "";
+  return `${server}/${repo}/actions/runs/${runId}`;
+}
+function reactToTriggerComment(cwd) {
+  if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath || !fs3.existsSync(eventPath)) return;
+  let event = null;
+  try {
+    event = JSON.parse(fs3.readFileSync(eventPath, "utf-8"));
+  } catch {
+    return;
+  }
+  const commentId = event?.comment?.id;
+  const repo = process.env.GITHUB_REPOSITORY;
+  if (!commentId || !repo) return;
+  const token = process.env.KODY_TOKEN?.trim() || process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+  try {
+    execFileSync3(
+      "gh",
+      [
+        "api",
+        "-X",
+        "POST",
+        "-H",
+        "Accept: application/vnd.github+json",
+        `/repos/${repo}/issues/comments/${commentId}/reactions`,
+        "-f",
+        "content=eyes"
+      ],
+      {
+        cwd,
+        env: { ...process.env, GH_TOKEN: token ?? process.env.GH_TOKEN ?? "" },
+        stdio: "pipe",
+        timeout: 15e3
+      }
+    );
+  } catch {
+  }
+}
+
+// src/scripts/runFlow.ts
+var runFlow = async (ctx) => {
+  const issueNumber = ctx.args.issue;
+  const issue = getIssue(issueNumber, ctx.cwd);
+  ctx.data.issue = issue;
+  ctx.data.commentTargetType = "issue";
+  ctx.data.commentTargetNumber = issueNumber;
+  try {
+    const branchInfo = ensureFeatureBranch(issueNumber, issue.title, ctx.config.git.defaultBranch, ctx.cwd);
+    ctx.data.branch = branchInfo.branch;
+  } catch (err) {
+    if (err instanceof UncommittedChangesError) {
+      ctx.output.exitCode = 5;
+      ctx.output.reason = err.message;
+      ctx.skipAgent = true;
+      tryPost(issueNumber, `\u26A0\uFE0F kody2 refused to start: ${err.message}`, ctx.cwd);
+      return;
+    }
+    throw err;
+  }
+  const runUrl = getRunUrl();
+  const startMsg = runUrl ? `\u2699\uFE0F kody2 started \u2014 branch \`${ctx.data.branch}\`, run ${runUrl}` : `\u2699\uFE0F kody2 started \u2014 branch \`${ctx.data.branch}\``;
+  tryPost(issueNumber, startMsg, ctx.cwd);
+};
+function tryPost(issueNumber, body, cwd) {
+  try {
+    postIssueComment(issueNumber, body, cwd);
+  } catch {
+  }
+}
+
+// src/scripts/fixFlow.ts
+var fixFlow = async (ctx) => {
+  const prNumber = ctx.args.pr;
+  const pr = getPr(prNumber, ctx.cwd);
+  if (pr.state !== "OPEN") {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `PR #${prNumber} is not OPEN (state: ${pr.state})`;
+    ctx.skipAgent = true;
+    return;
+  }
+  ctx.data.pr = pr;
+  ctx.data.commentTargetType = "pr";
+  ctx.data.commentTargetNumber = prNumber;
+  checkoutPrBranch(prNumber, ctx.cwd);
+  ctx.data.branch = getCurrentBranch(ctx.cwd);
+  const inlineFeedback = ctx.args.feedback?.trim();
+  const feedback = inlineFeedback || getPrLatestReviewBody(prNumber, ctx.cwd);
+  if (!feedback.trim()) {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "no --feedback provided and no review/body text found on PR";
+    ctx.skipAgent = true;
+    return;
+  }
+  ctx.data.feedback = feedback;
+  ctx.data.prDiff = getPrDiff(prNumber, ctx.cwd);
+  const runUrl = getRunUrl();
+  const runSuffix = runUrl ? `, run ${runUrl}` : "";
+  tryPostPr(
+    prNumber,
+    `\u2699\uFE0F kody2 fix started on \`${ctx.data.branch}\`${runSuffix} \u2014 applying feedback (${truncate(feedback.replace(/\n/g, " "), 200)})`,
+    ctx.cwd
+  );
+};
+function tryPostPr(prNumber, body, cwd) {
+  try {
+    postPrReviewComment(prNumber, body, cwd);
+  } catch {
+  }
+}
+
+// src/workflow.ts
+import { execFileSync as execFileSync4 } from "child_process";
+var GH_TIMEOUT_MS = 3e4;
+function ghToken2() {
+  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+}
+function gh2(args, cwd) {
+  const token = ghToken2();
+  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+  return execFileSync4("gh", args, {
+    encoding: "utf-8",
+    timeout: GH_TIMEOUT_MS,
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function getLatestFailedRunForPr(prNumber, cwd) {
+  let headBranch;
+  try {
+    const out = gh2(["pr", "view", String(prNumber), "--json", "headRefName"], cwd);
+    headBranch = JSON.parse(out).headRefName;
+  } catch {
+    return null;
+  }
+  if (!headBranch) return null;
+  try {
+    const out = gh2(
+      [
+        "run",
+        "list",
+        "--branch",
+        headBranch,
+        "--status",
+        "failure",
+        "--limit",
+        "1",
+        "--json",
+        "databaseId,workflowName,headBranch,conclusion,url,createdAt"
+      ],
+      cwd
+    );
+    const parsed = JSON.parse(out);
+    if (!Array.isArray(parsed) || parsed.length === 0) return null;
+    const r = parsed[0];
+    return {
+      id: String(r.databaseId ?? ""),
+      workflowName: r.workflowName ?? "",
+      headBranch: r.headBranch ?? headBranch,
+      conclusion: r.conclusion ?? "failure",
+      url: r.url ?? "",
+      createdAt: r.createdAt ?? ""
+    };
+  } catch {
+    return null;
+  }
+}
+function getFailedRunLogTail(runId, maxBytes, cwd) {
+  try {
+    const raw = gh2(["run", "view", String(runId), "--log-failed"], cwd);
+    if (raw.length <= maxBytes) return raw;
+    return raw.slice(-maxBytes);
+  } catch {
+    return "";
+  }
+}
+
+// src/scripts/fixCiFlow.ts
+var LOG_MAX_BYTES = 3e4;
+var fixCiFlow = async (ctx) => {
+  const prNumber = ctx.args.pr;
+  const pr = getPr(prNumber, ctx.cwd);
+  if (pr.state !== "OPEN") {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `PR #${prNumber} is not OPEN (state: ${pr.state})`;
+    ctx.skipAgent = true;
+    return;
+  }
+  ctx.data.pr = pr;
+  ctx.data.commentTargetType = "pr";
+  ctx.data.commentTargetNumber = prNumber;
+  checkoutPrBranch(prNumber, ctx.cwd);
+  ctx.data.branch = getCurrentBranch(ctx.cwd);
+  let runId = ctx.args.runId;
+  let workflowName = "";
+  let failedRunUrl = "";
+  if (!runId) {
+    const run = getLatestFailedRunForPr(prNumber, ctx.cwd);
+    if (!run) {
+      ctx.output.exitCode = 1;
+      ctx.output.reason = `no failed workflow run found on PR #${prNumber}'s branch`;
+      ctx.skipAgent = true;
+      return;
+    }
+    runId = run.id;
+    workflowName = run.workflowName;
+    failedRunUrl = run.url;
+  }
+  const logTail = getFailedRunLogTail(runId, LOG_MAX_BYTES, ctx.cwd);
+  if (!logTail) {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `failed to fetch log tail for run ${runId}`;
+    ctx.skipAgent = true;
+    return;
+  }
+  ctx.data.failedRunId = runId;
+  ctx.data.failedWorkflowName = workflowName;
+  ctx.data.failedRunUrl = failedRunUrl;
+  ctx.data.failedLogTail = logTail;
+  ctx.data.prDiff = getPrDiff(prNumber, ctx.cwd);
+  const runUrl = getRunUrl();
+  const runSuffix = runUrl ? `, kody2 run ${runUrl}` : "";
+  tryPostPr2(prNumber, `\u2699\uFE0F kody2 fix-ci started on \`${ctx.data.branch}\`${runSuffix} \u2014 analyzing workflow run ${runId}`, ctx.cwd);
+};
+function tryPostPr2(prNumber, body, cwd) {
+  try {
+    postPrReviewComment(prNumber, body, cwd);
+  } catch {
+  }
+}
+
+// src/scripts/resolveFlow.ts
+import { execFileSync as execFileSync5 } from "child_process";
+var CONFLICT_DIFF_MAX_BYTES = 4e4;
+var resolveFlow = async (ctx) => {
+  const prNumber = ctx.args.pr;
+  const pr = getPr(prNumber, ctx.cwd);
+  if (pr.state !== "OPEN") {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `PR #${prNumber} is not OPEN (state: ${pr.state})`;
+    ctx.skipAgent = true;
+    return;
+  }
+  ctx.data.pr = pr;
+  ctx.data.commentTargetType = "pr";
+  ctx.data.commentTargetNumber = prNumber;
+  checkoutPrBranch(prNumber, ctx.cwd);
+  ctx.data.branch = getCurrentBranch(ctx.cwd);
+  const baseBranch = pr.baseRefName || ctx.config.git.defaultBranch;
+  ctx.data.baseBranch = baseBranch;
+  const mergeStatus = mergeBase(baseBranch, ctx.cwd);
+  if (mergeStatus === "clean") {
+    ctx.output.exitCode = 0;
+    ctx.output.reason = `already up to date with origin/${baseBranch} \u2014 nothing to resolve`;
+    ctx.skipAgent = true;
+    tryPostPr3(prNumber, `\u2139\uFE0F kody2 resolve: ${ctx.output.reason}`, ctx.cwd);
+    return;
+  }
+  if (mergeStatus === "error") {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `failed to merge origin/${baseBranch} (non-conflict error); see runner log`;
+    ctx.skipAgent = true;
+    tryPostPr3(prNumber, `\u26A0\uFE0F kody2 resolve FAILED: ${ctx.output.reason}`, ctx.cwd);
+    return;
+  }
+  const conflictedFiles = getConflictedFiles(ctx.cwd);
+  if (conflictedFiles.length === 0) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = "merge reported conflict but no unmerged paths detected";
+    ctx.skipAgent = true;
+    return;
+  }
+  ctx.data.conflictedFiles = conflictedFiles;
+  ctx.data.conflictMarkersPreview = getConflictMarkersPreview(conflictedFiles, ctx.cwd);
+  const runUrl = getRunUrl();
+  const runSuffix = runUrl ? `, run ${runUrl}` : "";
+  tryPostPr3(prNumber, `\u2699\uFE0F kody2 resolve started on \`${ctx.data.branch}\`${runSuffix} \u2014 ${conflictedFiles.length} conflicted file(s)`, ctx.cwd);
+};
+function getConflictedFiles(cwd) {
+  try {
+    const out = execFileSync5("git", ["diff", "--name-only", "--diff-filter=U"], {
+      encoding: "utf-8",
+      cwd,
+      env: { ...process.env, HUSKY: "0" }
+    }).trim();
+    return out ? out.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTES) {
+  const chunks = [];
+  let total = 0;
+  for (const f of files) {
+    try {
+      const content = execFileSync5("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const snippet = `### ${f}
+
+\`\`\`
+${content.slice(0, 6e3)}
+\`\`\`
+`;
+      total += snippet.length;
+      chunks.push(snippet);
+      if (total >= maxBytes) break;
+    } catch {
+    }
+  }
+  return chunks.join("\n");
+}
+function tryPostPr3(prNumber, body, cwd) {
+  try {
+    postPrReviewComment(prNumber, body, cwd);
+  } catch {
+  }
+}
+
+// src/prompt.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+var CONVENTIONS_PER_FILE_MAX_BYTES = 3e4;
+var CONVENTION_FILES = ["CLAUDE.md", "AGENTS.md"];
+function loadProjectConventions(projectDir) {
+  const out = [];
+  for (const rel of CONVENTION_FILES) {
+    const abs = path3.join(projectDir, rel);
+    if (!fs4.existsSync(abs)) continue;
+    let content;
+    try {
+      content = fs4.readFileSync(abs, "utf-8");
+    } catch {
+      continue;
+    }
+    const truncated = content.length > CONVENTIONS_PER_FILE_MAX_BYTES;
+    if (truncated) content = content.slice(0, CONVENTIONS_PER_FILE_MAX_BYTES) + "\n\n\u2026 (truncated)";
+    out.push({ path: rel, content, truncated });
+  }
+  return out;
+}
+function parseAgentResult(finalText) {
+  const text = (finalText || "").trim();
+  if (!text) return { done: false, commitMessage: "", prSummary: "", failureReason: "agent produced no final message" };
+  const failedMatch = text.match(/(?:^|\n)\s*FAILED\s*:\s*(.+?)\s*$/s);
+  if (failedMatch) {
+    return { done: false, commitMessage: "", prSummary: "", failureReason: failedMatch[1].trim() };
+  }
+  if (!/(^|\n)\s*DONE\b/i.test(text)) {
+    return { done: false, commitMessage: "", prSummary: "", failureReason: "no DONE or FAILED marker in agent output" };
+  }
+  const commitMatch = text.match(/^[ \t]*COMMIT_MSG\s*:\s*(.+)$/im);
+  const commitMessage = commitMatch ? commitMatch[1].trim() : "";
+  const summaryStart = text.search(/(^|\n)[ \t]*PR_SUMMARY\s*:[ \t]*\n/i);
+  let prSummary = "";
+  if (summaryStart !== -1) {
+    const afterMarker = text.slice(summaryStart).replace(/^[\s\S]*?PR_SUMMARY\s*:[ \t]*\n/i, "");
+    prSummary = afterMarker.replace(/\n\s*```\s*$/g, "").replace(/```\s*$/g, "").trim();
+  }
+  return { done: true, commitMessage, prSummary, failureReason: "" };
+}
+
+// src/scripts/loadConventions.ts
+var loadConventions = async (ctx) => {
+  const conventions = loadProjectConventions(ctx.cwd);
+  ctx.data.conventions = conventions;
+  if (conventions.length > 0) {
+    process.stderr.write(`[kody2] loaded conventions: ${conventions.map((c) => c.path).join(", ")}
+`);
+  }
+};
+
+// src/scripts/loadCoverageRules.ts
+var loadCoverageRules = async (ctx) => {
+  ctx.data.coverageRules = ctx.config.testRequirements ?? [];
+};
+
+// src/scripts/composePrompt.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
+var composePrompt = async (ctx, profile) => {
+  const explicit = ctx.data.promptTemplate;
+  const mode = ctx.args.mode;
+  const candidates = [
+    explicit ? path4.join(profile.dir, explicit) : null,
+    mode ? path4.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path4.join(profile.dir, "prompt.md")
+  ].filter(Boolean);
+  let templatePath = "";
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) {
+      templatePath = c;
+      break;
+    }
+  }
+  if (!templatePath) {
+    throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
+  }
+  const template = fs5.readFileSync(templatePath, "utf-8");
+  const tokens = {
+    ...stringifyAll(ctx.args, "args."),
+    ...stringifyAll(ctx.data, ""),
+    "conventionsBlock": formatConventions(ctx.data.conventions),
+    "coverageBlock": formatCoverageBlock(ctx.data.coverageRules),
+    "toolsUsage": formatToolsUsage(profile),
+    "systemPromptAppend": profile.claudeCode.systemPromptAppend ?? "",
+    "repoOwner": ctx.config.github.owner,
+    "repoName": ctx.config.github.repo,
+    "defaultBranch": ctx.config.git.defaultBranch,
+    "branch": ctx.data.branch ?? ""
+  };
+  ctx.data.prompt = template.replace(MUSTACHE, (_, key) => tokens[key] ?? "");
+};
+function stringifyAll(source, prefix) {
+  const out = {};
+  for (const [k, v] of Object.entries(source)) {
+    const key = prefix + k;
+    if (v === null || v === void 0) continue;
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      out[key] = String(v);
+    } else if (Array.isArray(v)) {
+      out[key] = v.map((x) => typeof x === "string" ? x : JSON.stringify(x)).join("\n");
+    } else if (typeof v === "object") {
+      for (const [k2, v2] of Object.entries(v)) {
+        if (typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean") {
+          out[`${key}.${k2}`] = String(v2);
+        }
+      }
+    }
+  }
+  return out;
+}
+function formatConventions(conventions) {
+  if (!conventions || conventions.length === 0) return "";
+  const lines = [
+    "# Project conventions (AUTHORITATIVE \u2014 follow these over patterns you infer from code)",
+    ""
+  ];
+  for (const c of conventions) {
+    lines.push(`## ${c.path}${c.truncated ? " (truncated)" : ""}`);
+    lines.push("");
+    lines.push("```");
+    lines.push(c.content);
+    lines.push("```");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatCoverageBlock(reqs) {
+  if (!reqs || reqs.length === 0) return "";
+  const lines = [
+    "# Test coverage requirements (ENFORCED)",
+    "",
+    "Every newly added file matching one of these patterns MUST be accompanied by a sibling test file in the same commit. The wrapper checks this after you finish; if any sibling test is missing, the run will fail and the issue will be re-invoked with the gap as feedback.",
+    ""
+  ];
+  for (const r of reqs) lines.push(`- new \`${r.pattern}\` \u2192 must include sibling \`${r.requireSibling}\``);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatToolsUsage(profile) {
+  const entries = (profile.cliTools ?? []).filter((t) => t.usage.trim().length > 0);
+  if (entries.length === 0) return "";
+  const lines = [
+    "# Available CLI tools",
+    ""
+  ];
+  for (const t of entries) {
+    lines.push(`## \`${t.name}\``);
+    lines.push(t.usage);
+    if (t.allowedUses.length > 0) {
+      lines.push(`Allowed sub-commands: ${t.allowedUses.map((u) => "`" + u + "`").join(", ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/scripts/parseAgentResult.ts
+var parseAgentResult2 = async (ctx, _profile, agentResult) => {
+  if (!agentResult) {
+    ctx.data.agentDone = false;
+    return;
+  }
+  const parsed = parseAgentResult(agentResult.finalText);
+  ctx.data.agentDone = parsed.done;
+  ctx.data.commitMessage = parsed.commitMessage;
+  ctx.data.prSummary = parsed.prSummary;
+  ctx.data.agentFailureReason = parsed.failureReason;
+  ctx.data.agentOutcome = agentResult.outcome;
+  ctx.data.agentError = agentResult.error;
+};
+
+// src/verify.ts
+import { spawn } from "child_process";
+var TAIL_CHARS = 4e3;
+var COMMAND_TIMEOUT_MS = 10 * 60 * 1e3;
+function runCommand(command, cwd) {
+  return new Promise((resolve2) => {
+    const start = Date.now();
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const buffers = [];
+    let totalSize = 0;
+    const collect = (chunk) => {
+      buffers.push(chunk);
+      totalSize += chunk.length;
+      while (totalSize > TAIL_CHARS * 4 && buffers.length > 1) {
+        totalSize -= buffers[0].length;
+        buffers.shift();
+      }
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+    }, COMMAND_TIMEOUT_MS);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
+      resolve2({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve2({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+    });
+  });
+}
+async function verifyAll(config, cwd) {
+  const commands = [];
+  if (config.quality.typecheck) commands.push({ name: "typecheck", cmd: config.quality.typecheck });
+  if (config.quality.testUnit) commands.push({ name: "test", cmd: config.quality.testUnit });
+  if (config.quality.lint) commands.push({ name: "lint", cmd: config.quality.lint });
+  const failed = [];
+  const details = {};
+  for (const { name, cmd } of commands) {
+    const result = await runCommand(cmd, cwd);
+    details[name] = result;
+    if (result.exitCode !== 0) failed.push(name);
+  }
+  return { ok: failed.length === 0, failed, details };
+}
+var ANSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function summarizeFailure(result) {
+  const lines = [`verify failed: ${result.failed.join(", ")}`];
+  for (const name of result.failed) {
+    const d = result.details[name];
+    if (!d) continue;
+    lines.push(`
+--- ${name} (exit ${d.exitCode}, ${(d.durationMs / 1e3).toFixed(1)}s) ---`);
+    lines.push(stripAnsi(d.tail));
+  }
+  return lines.join("\n");
+}
+
+// src/scripts/verify.ts
+var verify = async (ctx) => {
+  try {
+    const result = await verifyAll(ctx.config, ctx.cwd);
+    ctx.data.verifyOk = result.ok;
+    ctx.data.verifyReason = result.ok ? "" : summarizeFailure(result);
+  } catch (err) {
+    ctx.data.verifyOk = false;
+    ctx.data.verifyReason = `verify crashed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+};
+
+// src/coverage.ts
+import { execFileSync as execFileSync6 } from "child_process";
+function patternToRegex(pattern) {
+  let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
+  s = s.replace(/§S/g, "(?:.*/)?").replace(/§A/g, ".*");
+  return new RegExp(`^${s}$`);
+}
+function renderSiblingPath(file, requireSibling) {
+  const lastSlash = file.lastIndexOf("/");
+  const dir = lastSlash === -1 ? "" : file.slice(0, lastSlash + 1);
+  const base = lastSlash === -1 ? file : file.slice(lastSlash + 1);
+  const name = base.replace(/\.[^.]+$/, "");
+  const ext = base.match(/\.[^.]+$/)?.[0] ?? "";
+  const sibling = requireSibling.replace(/\{name\}/g, name).replace(/\{ext\}/g, ext);
+  return dir + sibling;
+}
+function safeGit(args, cwd) {
+  try {
+    return execFileSync6("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+  } catch {
+    return "";
+  }
+}
+function getAddedFiles(baseBranch, cwd) {
+  const committed = safeGit(["diff", "--name-only", "--diff-filter=A", `origin/${baseBranch}...HEAD`], cwd);
+  const untracked = safeGit(["ls-files", "--others", "--exclude-standard"], cwd);
+  const set = /* @__PURE__ */ new Set();
+  for (const f of committed.split("\n")) if (f) set.add(f);
+  for (const f of untracked.split("\n")) if (f) set.add(f);
+  return [...set];
+}
+function checkCoverage(addedFiles, requirements) {
+  if (requirements.length === 0) return [];
+  const addedSet = new Set(addedFiles);
+  const misses = [];
+  for (const file of addedFiles) {
+    if (/\.(test|spec)\./.test(file)) continue;
+    for (const req of requirements) {
+      const re = patternToRegex(req.pattern);
+      if (!re.test(file)) continue;
+      const expected = renderSiblingPath(file, req.requireSibling);
+      if (!addedSet.has(expected)) {
+        misses.push({ file, expectedTest: expected });
+      }
+      break;
+    }
+  }
+  return misses;
+}
+function formatMissesForFeedback(misses) {
+  if (misses.length === 0) return "";
+  const lines = ["The following files were added without a sibling test file:"];
+  for (const m of misses) lines.push(`- \`${m.file}\` \u2192 expected \`${m.expectedTest}\``);
+  lines.push("");
+  lines.push("Add the missing test files. Each should cover the new file's public API with at least a happy path and one failure path. Then re-emit DONE / COMMIT_MSG / PR_SUMMARY.");
+  return lines.join("\n");
+}
+
+// src/scripts/checkCoverageWithRetry.ts
+var checkCoverageWithRetry = async (ctx) => {
+  const reqs = ctx.data.coverageRules ?? [];
+  if (reqs.length === 0) {
+    ctx.data.coverageMisses = [];
+    return;
+  }
+  if (!ctx.data.agentDone) {
+    ctx.data.coverageMisses = [];
+    return;
+  }
+  const misses = checkCoverage(getAddedFiles(ctx.config.git.defaultBranch, ctx.cwd), reqs);
+  if (misses.length === 0) {
+    ctx.data.coverageMisses = [];
+    return;
+  }
+  const invoker = ctx.data.__invokeAgent;
+  const basePrompt = ctx.data.prompt;
+  if (!invoker || !basePrompt) {
+    ctx.data.coverageMisses = misses;
+    return;
+  }
+  process.stderr.write(`[kody2] coverage check found ${misses.length} missing test(s); retrying agent once
+`);
+  const retryPrompt = `${basePrompt}
+
+# Coverage failure (retry)
+${formatMissesForFeedback(misses)}`;
+  const retry = await invoker(retryPrompt);
+  const retryParsed = parseAgentResult(retry.finalText);
+  if (retry.outcome === "completed" && retryParsed.done) {
+    ctx.data.agentDone = true;
+    ctx.data.commitMessage = retryParsed.commitMessage || ctx.data.commitMessage;
+    ctx.data.prSummary = retryParsed.prSummary || ctx.data.prSummary;
+  }
+  const finalMisses = checkCoverage(getAddedFiles(ctx.config.git.defaultBranch, ctx.cwd), reqs);
+  ctx.data.coverageMisses = finalMisses;
+};
+
+// src/scripts/commitAndPush.ts
+import { execFileSync as execFileSync8 } from "child_process";
+
+// src/commit.ts
+import { execFileSync as execFileSync7 } from "child_process";
+import * as fs6 from "fs";
+import * as path5 from "path";
+var FORBIDDEN_PATH_PREFIXES = [
+  ".kody/",
+  ".kody-engine/",
+  ".kody2/",
+  ".kody-lean/",
+  // back-compat: stale runtime dir from kody-lean v0.5.x
+  "node_modules/",
+  "dist/",
+  "build/"
+];
+var FORBIDDEN_PATH_EXACT = /* @__PURE__ */ new Set([".env"]);
+var FORBIDDEN_PATH_SUFFIXES = [".log"];
+var CONVENTIONAL_PREFIXES = [
+  "feat:",
+  "fix:",
+  "chore:",
+  "docs:",
+  "refactor:",
+  "test:",
+  "perf:",
+  "ci:",
+  "style:",
+  "build:",
+  "revert:"
+];
+function git2(args, cwd) {
+  try {
+    return execFileSync7("git", args, {
+      encoding: "utf-8",
+      timeout: 12e4,
+      cwd,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (err) {
+    const e = err;
+    const stderr = e.stderr?.toString().trim() ?? "";
+    const stdout = e.stdout?.toString().trim() ?? "";
+    const status = e.status ?? "?";
+    const detail = stderr || stdout || e.message || "(no output)";
+    throw new Error(`git ${args.join(" ")} (exit ${status}):
+${detail}`);
+  }
+}
+function tryGit(args, cwd) {
+  try {
+    git2(args, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function abortUnfinishedGitOps(cwd) {
+  const aborted = [];
+  const gitDir = path5.join(cwd ?? process.cwd(), ".git");
+  if (!fs6.existsSync(gitDir)) return aborted;
+  if (fs6.existsSync(path5.join(gitDir, "MERGE_HEAD"))) {
+    if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
+  }
+  if (fs6.existsSync(path5.join(gitDir, "CHERRY_PICK_HEAD"))) {
+    if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
+  }
+  if (fs6.existsSync(path5.join(gitDir, "REVERT_HEAD"))) {
+    if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
+  }
+  if (fs6.existsSync(path5.join(gitDir, "rebase-merge")) || fs6.existsSync(path5.join(gitDir, "rebase-apply"))) {
+    if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
+  }
+  try {
+    const unmerged = git2(["diff", "--name-only", "--diff-filter=U"], cwd);
+    if (unmerged) {
+      tryGit(["reset", "--mixed", "HEAD"], cwd);
+      aborted.push("unmerged-paths-reset");
+    }
+  } catch {
+  }
+  return aborted;
+}
+function isForbiddenPath(p) {
+  if (FORBIDDEN_PATH_EXACT.has(p)) return true;
+  for (const pre of FORBIDDEN_PATH_PREFIXES) if (p.startsWith(pre)) return true;
+  for (const suf of FORBIDDEN_PATH_SUFFIXES) if (p.endsWith(suf)) return true;
+  return false;
+}
+function listChangedFiles(cwd) {
+  const raw = execFileSync7("git", ["status", "--porcelain=v1", "-z"], {
+    encoding: "utf-8",
+    cwd,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (!raw) return [];
+  const entries = raw.split("\0").filter((e) => e.length > 0);
+  return entries.map((e) => e.slice(3)).filter(Boolean);
+}
+function normalizeCommitMessage(raw) {
+  const trimmed = raw.trim().replace(/^['"]|['"]$/g, "").trim();
+  if (!trimmed) return "chore: kody2 update";
+  const firstLine2 = trimmed.split("\n")[0];
+  for (const prefix of CONVENTIONAL_PREFIXES) {
+    if (firstLine2.toLowerCase().startsWith(prefix)) return trimmed;
+  }
+  return `chore: ${trimmed}`;
+}
+function commitAndPush(branch, agentMessage, cwd) {
+  const allChanged = listChangedFiles(cwd);
+  const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
+  const mergeHeadExists = fs6.existsSync(path5.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  if (allowedFiles.length === 0 && !mergeHeadExists) {
+    return { committed: false, pushed: false, sha: "", message: "" };
+  }
+  for (const f of allowedFiles) {
+    try {
+      git2(["add", "--", f], cwd);
+    } catch {
+    }
+  }
+  const message = normalizeCommitMessage(agentMessage);
+  try {
+    git2(["commit", "--no-gpg-sign", "-m", message], cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/nothing to commit/i.test(msg)) {
+      return { committed: false, pushed: false, sha: "", message };
+    }
+    throw err;
+  }
+  const sha = git2(["rev-parse", "HEAD"], cwd).slice(0, 7);
+  try {
+    git2(["push", "-u", "origin", branch], cwd);
+  } catch {
+    git2(["push", "--force-with-lease", "-u", "origin", branch], cwd);
+  }
+  return { committed: true, pushed: true, sha, message };
+}
+function hasCommitsAhead(branch, defaultBranch, cwd) {
+  try {
+    const out = git2(["rev-list", "--count", `origin/${defaultBranch}..${branch}`], cwd);
+    return parseInt(out, 10) > 0;
+  } catch {
+    try {
+      const out = git2(["rev-list", "--count", `${defaultBranch}..${branch}`], cwd);
+      return parseInt(out, 10) > 0;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/scripts/commitAndPush.ts
+var commitAndPush2 = async (ctx) => {
+  const branch = ctx.data.branch;
+  if (!branch) {
+    ctx.data.commitResult = { committed: false, pushed: false };
+    return;
+  }
+  if (ctx.args.mode === "resolve") {
+    try {
+      execFileSync8("git", ["add", "-A"], { cwd: ctx.cwd, env: { ...process.env, HUSKY: "0" }, stdio: "pipe" });
+    } catch {
+    }
+  } else {
+    const aborted = abortUnfinishedGitOps(ctx.cwd);
+    if (aborted.length > 0) {
+      process.stderr.write(`[kody2] cleaned up unfinished git ops: ${aborted.join(", ")}
+`);
+    }
+  }
+  const fallbackMsg = defaultCommitMessage(ctx.args.mode, ctx.data);
+  const message = ctx.data.commitMessage || fallbackMsg;
+  try {
+    const result = commitAndPush(branch, message, ctx.cwd);
+    ctx.data.commitResult = result;
+    ctx.data.changedFiles = listChangedFiles(ctx.cwd).filter((f) => !isForbiddenPath(f));
+  } catch (err) {
+    ctx.data.commitCrash = err instanceof Error ? err.message : String(err);
+    ctx.data.commitResult = { committed: false, pushed: false };
+  }
+  ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
+};
+function defaultCommitMessage(mode, data) {
+  switch (mode) {
+    case "run":
+      return `chore: kody2 changes for #${data.commentTargetNumber}`;
+    case "fix":
+      return `chore(fix): kody2 fix for PR #${data.commentTargetNumber}`;
+    case "fix-ci":
+      return `fix(ci): kody2 fix-ci for PR #${data.commentTargetNumber}`;
+    case "resolve":
+      return `fix: resolve merge conflicts with ${data.baseBranch}`;
+    default:
+      return `chore: kody2 changes`;
+  }
+}
+
+// src/pr.ts
+var TITLE_MAX = 72;
+function buildPrTitle(issueNumber, issueTitle, draft) {
+  const prefix = draft ? "[WIP] " : "";
+  const base = `${prefix}#${issueNumber}: ${issueTitle}`;
+  if (base.length <= TITLE_MAX) return base;
+  return base.slice(0, TITLE_MAX - 1) + "\u2026";
+}
+function buildPrBody(opts) {
+  const lines = [];
+  if (opts.draft && opts.failureReason) {
+    const headline = firstLine(opts.failureReason);
+    lines.push(`> \u26A0\uFE0F Draft: ${headline}`);
+    lines.push(`> The failures below may be **pre-existing in the repo** \u2014 verify before treating as PR-blocking.`);
+    lines.push("");
+  }
+  lines.push("## Summary");
+  lines.push("");
+  if (opts.agentSummary && opts.agentSummary.trim()) {
+    lines.push(opts.agentSummary.trim());
+  } else {
+    lines.push(`Implementation of issue #${opts.issueNumber} \u2014 ${opts.issueTitle}`);
+    lines.push("");
+    lines.push("_(agent did not supply PR_SUMMARY)_");
+  }
+  lines.push("");
+  if (opts.changedFiles.length > 0) {
+    lines.push("## Changes");
+    lines.push("");
+    for (const f of opts.changedFiles.slice(0, 50)) lines.push(`- \`${f}\``);
+    if (opts.changedFiles.length > 50) lines.push(`- \u2026 and ${opts.changedFiles.length - 50} more`);
+    lines.push("");
+  }
+  lines.push(`Closes #${opts.issueNumber}`);
+  lines.push("");
+  if (opts.draft && opts.failureReason) {
+    lines.push("<details>");
+    lines.push("<summary>Verify output (click to expand)</summary>");
+    lines.push("");
+    lines.push("```");
+    lines.push(truncate(opts.failureReason, 6e3));
+    lines.push("```");
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("_Opened by kody2 (single-session autonomous run)._ ");
+  return lines.join("\n");
+}
+function firstLine(s) {
+  const trimmed = s.trim();
+  const nl = trimmed.indexOf("\n");
+  const head = nl === -1 ? trimmed : trimmed.slice(0, nl);
+  return head.length > 200 ? head.slice(0, 197) + "\u2026" : head;
+}
+function findExistingPr(branch, cwd) {
+  try {
+    const output = gh(["pr", "view", branch, "--json", "number,url"], { cwd });
+    const parsed = JSON.parse(output);
+    if (typeof parsed?.number === "number" && typeof parsed?.url === "string") {
+      return { number: parsed.number, url: parsed.url };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function ensurePr(opts) {
+  const title = buildPrTitle(opts.issueNumber, opts.issueTitle, opts.draft);
+  const body = buildPrBody(opts);
+  const existing = findExistingPr(opts.branch, opts.cwd);
+  if (existing) {
+    try {
+      gh(
+        ["pr", "edit", String(existing.number), "--body-file", "-"],
+        { input: body, cwd: opts.cwd }
+      );
+    } catch (err) {
+      process.stderr.write(`[kody2] failed to update PR #${existing.number}: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+    return { url: existing.url, number: existing.number, draft: opts.draft, action: "updated" };
+  }
+  const args = [
+    "pr",
+    "create",
+    "--head",
+    opts.branch,
+    "--base",
+    opts.defaultBranch,
+    "--title",
+    title,
+    "--body-file",
+    "-"
+  ];
+  if (opts.draft) args.push("--draft");
+  const output = gh(args, { input: body, cwd: opts.cwd });
+  const url = output.trim();
+  const match = url.match(/\/pull\/(\d+)$/);
+  const number = match ? parseInt(match[1], 10) : 0;
+  return { url, number, draft: opts.draft, action: "created" };
+}
+
+// src/scripts/ensurePr.ts
+var ensurePr2 = async (ctx) => {
+  if (ctx.skipAgent && ctx.output.exitCode !== void 0 && ctx.output.exitCode !== 0) {
+    return;
+  }
+  const commitResult = ctx.data.commitResult;
+  const hasCommits = Boolean(ctx.data.hasCommitsAhead);
+  if (!commitResult?.committed && !hasCommits) {
+    return;
+  }
+  const branch = ctx.data.branch;
+  if (!branch) return;
+  const failureReason = computeFailureReason(ctx);
+  const isFailure = failureReason.length > 0;
+  const changedFiles = ctx.data.changedFiles ?? [];
+  const issue = ctx.data.issue;
+  const pr = ctx.data.pr;
+  const targetNumber = Number(ctx.data.commentTargetNumber ?? 0);
+  const title = issue?.title ?? pr?.title ?? `kody2 changes`;
+  try {
+    const result = ensurePr({
+      branch,
+      defaultBranch: ctx.config.git.defaultBranch,
+      issueNumber: targetNumber,
+      issueTitle: title,
+      draft: isFailure,
+      failureReason: isFailure ? failureReason : void 0,
+      changedFiles,
+      agentSummary: ctx.data.prSummary,
+      cwd: ctx.cwd
+    });
+    ctx.output.prUrl = result.url;
+    ctx.data.prResult = result;
+  } catch (err) {
+    const reason = `PR creation failed: ${err instanceof Error ? err.message : String(err)}`;
+    ctx.data.prCrashReason = reason;
+    ctx.output.exitCode = 4;
+    ctx.output.reason = reason;
+  }
+};
+function computeFailureReason(ctx) {
+  const misses = ctx.data.coverageMisses ?? [];
+  if (misses.length > 0) return `missing tests: ${misses.map((m) => m.expectedTest).join(", ")}`;
+  const agentDone = Boolean(ctx.data.agentDone);
+  if (!agentDone) {
+    return ctx.data.agentFailureReason || ctx.data.agentError || ctx.data.commitCrash || "agent did not emit DONE";
+  }
+  if (ctx.data.verifyOk === false) return ctx.data.verifyReason || "verify failed";
+  return "";
+}
+
+// src/scripts/postIssueComment.ts
+var postIssueComment2 = async (ctx) => {
+  if (ctx.skipAgent && ctx.output.exitCode !== void 0) return;
+  const targetType = ctx.data.commentTargetType;
+  const targetNumber = Number(ctx.data.commentTargetNumber ?? 0);
+  if (!targetType || !targetNumber) return;
+  const commitResult = ctx.data.commitResult;
+  const hasCommits = Boolean(ctx.data.hasCommitsAhead);
+  const prUrl = ctx.output.prUrl;
+  if (!commitResult?.committed && !hasCommits) {
+    const reason = "no changes to commit";
+    postWith(targetType, targetNumber, `\u26A0\uFE0F kody2 FAILED: ${reason}`, ctx.cwd);
+    ctx.output.exitCode = 3;
+    ctx.output.reason = reason;
+    return;
+  }
+  if (ctx.output.exitCode === 4 && ctx.data.prCrashReason) {
+    postWith(targetType, targetNumber, `\u26A0\uFE0F kody2 FAILED: ${truncate(ctx.data.prCrashReason, 1500)}`, ctx.cwd);
+    ctx.output.reason = ctx.data.prCrashReason;
+    return;
+  }
+  const failureReason = computeFailureReason2(ctx);
+  const isFailure = failureReason.length > 0;
+  const msg = isFailure ? `\u26A0\uFE0F kody2 FAILED: ${truncate(failureReason, 1500)}${prUrl ? ` \u2014 draft PR: ${prUrl}` : ""}` : `\u2705 kody2 PR opened: ${prUrl}`;
+  postWith(targetType, targetNumber, msg, ctx.cwd);
+  let exitCode = 0;
+  const agentDone = Boolean(ctx.data.agentDone);
+  const verifyOk = ctx.data.verifyOk !== false;
+  const misses = ctx.data.coverageMisses ?? [];
+  if (!agentDone || misses.length > 0) exitCode = 1;
+  else if (!verifyOk) exitCode = 2;
+  ctx.output.exitCode = exitCode;
+  ctx.output.reason = failureReason || void 0;
+};
+function computeFailureReason2(ctx) {
+  const misses = ctx.data.coverageMisses ?? [];
+  if (misses.length > 0) return `missing tests: ${misses.map((m) => m.expectedTest).join(", ")}`;
+  const agentDone = Boolean(ctx.data.agentDone);
+  if (!agentDone) {
+    return ctx.data.agentFailureReason || ctx.data.agentError || "agent did not emit DONE";
+  }
+  if (ctx.data.verifyOk === false) return ctx.data.verifyReason || "verify failed";
+  return "";
+}
+function postWith(type, n, body, cwd) {
+  try {
+    if (type === "issue") postIssueComment(n, body, cwd);
+    else postPrReviewComment(n, body, cwd);
+  } catch {
+  }
+}
+
+// src/scripts/index.ts
+var preflightScripts = {
+  runFlow,
+  fixFlow,
+  fixCiFlow,
+  resolveFlow,
+  loadConventions,
+  loadCoverageRules,
+  composePrompt
+};
+var postflightScripts = {
+  parseAgentResult: parseAgentResult2,
+  verify,
+  checkCoverageWithRetry,
+  commitAndPush: commitAndPush2,
+  ensurePr: ensurePr2,
+  postIssueComment: postIssueComment2
+};
+var allScriptNames = /* @__PURE__ */ new Set([
+  ...Object.keys(preflightScripts),
+  ...Object.keys(postflightScripts)
+]);
+
+// src/agent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import * as fs7 from "fs";
+import * as path6 from "path";
+
+// src/format.ts
+function renderEvent(msg, opts = {}) {
+  if (opts.quiet) {
+    if (msg.type === "result") return formatResult(msg);
+    return null;
+  }
+  switch (msg.type) {
+    case "system":
+      return null;
+    case "assistant":
+      return formatAssistant(msg, opts);
+    case "user":
+      return formatUserToolResult(msg, opts);
+    case "result":
+      return formatResult(msg);
+    default:
+      return null;
+  }
+}
+function formatAssistant(msg, opts) {
+  const content = msg.message?.content ?? [];
+  const lines = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      const text = block.text.trim();
+      if (text) lines.push(text);
+    } else if (block.type === "tool_use") {
+      const tu = block;
+      lines.push(`\u2192 ${tu.name}${summarizeToolInput(tu.name, tu.input)}`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function formatUserToolResult(msg, opts) {
+  const content = msg.message?.content ?? [];
+  const lines = [];
+  for (const block of content) {
+    if (block.type === "tool_result") {
+      const tr = block;
+      const text = stringifyToolContent(tr.content);
+      const lineCount = text.split("\n").length;
+      const sizeBytes = text.length;
+      const flag = tr.is_error ? " ERROR" : "";
+      const summary = `  \u21B3${flag} ${lineCount} lines, ${formatBytes(sizeBytes)}`;
+      if (opts.verbose) {
+        lines.push(`${summary}
+${truncate2(text, 4e3)}`);
+      } else {
+        lines.push(summary);
+      }
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function formatResult(msg) {
+  const ok = msg.subtype === "success";
+  const tag = ok ? "DONE" : `FAILED (${msg.subtype ?? "unknown"})`;
+  const dur = msg.duration_ms ? ` ${(msg.duration_ms / 1e3).toFixed(1)}s` : "";
+  const turns = msg.num_turns ? ` ${msg.num_turns} turns` : "";
+  const cost = typeof msg.total_cost_usd === "number" ? ` $${msg.total_cost_usd.toFixed(4)}` : "";
+  return `
+=== ${tag}${dur}${turns}${cost} ===`;
+}
+function summarizeToolInput(toolName, input = {}) {
+  if (toolName === "Bash" && typeof input.command === "string") {
+    const cmd = input.command.split("\n")[0];
+    return `: ${truncate2(cmd, 120)}`;
+  }
+  if ((toolName === "Read" || toolName === "Edit" || toolName === "Write") && typeof input.file_path === "string") {
+    return ` ${input.file_path}`;
+  }
+  if ((toolName === "Glob" || toolName === "Grep") && typeof input.pattern === "string") {
+    return `: ${truncate2(input.pattern, 80)}`;
+  }
+  return "";
+}
+function stringifyToolContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => {
+      if (b && typeof b === "object" && "text" in b && typeof b.text === "string") {
+        return b.text;
+      }
+      return JSON.stringify(b);
+    }).join("\n");
+  }
+  return JSON.stringify(content);
+}
+function truncate2(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max) + `\u2026 (+${s.length - max} chars)`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+// src/agent.ts
+var DEFAULT_ALLOWED_TOOLS = ["Bash", "Edit", "Read", "Write", "Glob", "Grep"];
+async function runAgent(opts) {
+  const ndjsonDir = opts.ndjsonDir ?? path6.join(opts.cwd, ".kody2");
+  fs7.mkdirSync(ndjsonDir, { recursive: true });
+  const ndjsonPath = path6.join(ndjsonDir, "last-run.jsonl");
+  const fullLog = fs7.createWriteStream(ndjsonPath, { flags: "w" });
+  const env = {
+    ...process.env,
+    SKIP_HOOKS: "1",
+    HUSKY: "0",
+    CI: process.env.CI ?? "1"
+  };
+  if (opts.litellmUrl) {
+    env.ANTHROPIC_BASE_URL = opts.litellmUrl;
+    env.ANTHROPIC_API_KEY = getAnthropicApiKeyOrDummy();
+  }
+  let finalText = "";
+  let outcome = "failed";
+  let errorMessage;
+  try {
+    const result = query({
+      prompt: opts.prompt,
+      options: {
+        model: opts.model.model,
+        cwd: opts.cwd,
+        allowedTools: opts.allowedToolsOverride ?? DEFAULT_ALLOWED_TOOLS,
+        permissionMode: opts.permissionModeOverride ?? "acceptEdits",
+        env
+      }
+    });
+    for await (const msg of result) {
+      try {
+        fullLog.write(JSON.stringify(msg) + "\n");
+      } catch {
+      }
+      const line = renderEvent(msg, { verbose: opts.verbose, quiet: opts.quiet });
+      if (line) process.stdout.write(line + "\n");
+      const m = msg;
+      if (m.type === "result") {
+        if (m.subtype === "success") {
+          outcome = "completed";
+          finalText = (typeof m.result === "string" ? m.result : "").trim();
+        } else {
+          outcome = "failed";
+          errorMessage = `result subtype: ${m.subtype ?? "unknown"}`;
+        }
+      }
+    }
+  } catch (e) {
+    outcome = "failed";
+    errorMessage = e instanceof Error ? e.message : String(e);
+  } finally {
+    try {
+      fullLog.end();
+    } catch {
+    }
+  }
+  return { outcome, finalText, error: errorMessage, ndjsonPath };
+}
+
+// src/tools.ts
+import { execFileSync as execFileSync9 } from "child_process";
+function verifyCliTools(tools, cwd) {
+  const out = [];
+  for (const t of tools) out.push(verifyOne(t, cwd));
+  return out;
+}
+function firstRequiredFailure(results, tools) {
+  for (const t of tools) {
+    const r = results.find((x) => x.name === t.name);
+    if (!r) continue;
+    if (t.install.required && (!r.present || !r.verified)) return r;
+  }
+  return null;
+}
+function verifyOne(tool, cwd) {
+  const result = { name: tool.name, present: false, verified: false };
+  let present = runShell(tool.install.checkCommand, cwd);
+  if (!present && tool.install.installCommand) {
+    runShell(tool.install.installCommand, cwd, 12e4);
+    present = runShell(tool.install.checkCommand, cwd);
+  }
+  result.present = present;
+  if (!present) {
+    result.error = `tool "${tool.name}" not on PATH (check: ${tool.install.checkCommand})`;
+    return result;
+  }
+  const verified = runShell(tool.verify, cwd);
+  result.verified = verified;
+  if (!verified) result.error = `tool "${tool.name}" failed verify: ${tool.verify}`;
+  return result;
+}
+function runShell(cmd, cwd, timeoutMs = 3e4) {
+  try {
+    execFileSync9("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/litellm.ts
+import * as fs8 from "fs";
+import * as os from "os";
+import * as path7 from "path";
+import { execFileSync as execFileSync10, spawn as spawn2 } from "child_process";
+async function checkLitellmHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function generateLitellmConfigYaml(model) {
+  const apiKeyVar = providerApiKeyEnvVar(model.provider);
+  return [
+    "model_list:",
+    `  - model_name: ${model.model}`,
+    `    litellm_params:`,
+    `      model: ${model.provider}/${model.model}`,
+    `      api_key: os.environ/${apiKeyVar}`,
+    "",
+    "litellm_settings:",
+    "  drop_params: true",
+    ""
+  ].join("\n");
+}
+async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL) {
+  if (!needsLitellmProxy(model)) return null;
+  if (await checkLitellmHealth(url)) {
+    return { url, kill: () => {
+    } };
+  }
+  let cmd = "litellm";
+  let args;
+  try {
+    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+  } catch {
+    try {
+      execFileSync10("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      cmd = "python3";
+    } catch {
+      throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
+    }
+  }
+  const configPath = path7.join(os.tmpdir(), `kody2-litellm-${Date.now()}.yaml`);
+  fs8.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const portMatch = url.match(/:(\d+)/);
+  const port = portMatch ? portMatch[1] : "4000";
+  args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
+  const dotenvVars = readDotenvApiKeys(projectDir);
+  const logPath = path7.join(os.tmpdir(), `kody2-litellm-${Date.now()}.log`);
+  const outFd = fs8.openSync(logPath, "w");
+  const child = spawn2(cmd, args, {
+    stdio: ["ignore", outFd, outFd],
+    detached: true,
+    env: stripBlockingEnv({ ...process.env, ...dotenvVars })
+  });
+  fs8.closeSync(outFd);
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (await checkLitellmHealth(url)) {
+      return { url, kill: () => {
+        try {
+          child.kill();
+        } catch {
+        }
+      } };
+    }
+  }
+  let logTail = "";
+  try {
+    logTail = fs8.readFileSync(logPath, "utf-8").slice(-2e3);
+  } catch {
+  }
+  try {
+    child.kill();
+  } catch {
+  }
+  throw new Error(`LiteLLM proxy failed to start within 60s. Log tail:
+${logTail}`);
+}
+function readDotenvApiKeys(projectDir) {
+  const dotenvPath = path7.join(projectDir, ".env");
+  if (!fs8.existsSync(dotenvPath)) return {};
+  const result = {};
+  for (const rawLine of fs8.readFileSync(dotenvPath, "utf-8").split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const commentIdx = value.indexOf(" #");
+    if (commentIdx !== -1) value = value.slice(0, commentIdx).trim();
+    if (value) result[match[1]] = value;
+  }
+  return result;
+}
+function stripBlockingEnv(env) {
+  const out = { ...env };
+  delete out.DATABASE_URL;
+  delete out.AI_BASE_URL;
+  return out;
+}
+
+// src/executor.ts
+async function runExecutable(profileName, input) {
+  const profilePath = resolveProfilePath(profileName);
+  const profile = loadProfile(profilePath);
+  const missing = validateScriptReferences(profile, allScriptNames);
+  if (missing.length > 0) {
+    return finish({ exitCode: 99, reason: `profile references unknown scripts: ${missing.join(", ")}` });
+  }
+  let args;
+  try {
+    args = validateInputs(profile.inputs, input.cliArgs);
+  } catch (err) {
+    return finish({ exitCode: 64, reason: err instanceof Error ? err.message : String(err) });
+  }
+  const toolResults = verifyCliTools(profile.cliTools, input.cwd);
+  const firstFail = firstRequiredFailure(toolResults, profile.cliTools);
+  if (firstFail) {
+    return finish({ exitCode: 99, reason: `required CLI tool check failed: ${firstFail.error}` });
+  }
+  const modelSpec = profile.claudeCode.model === "inherit" ? input.config.agent.model : profile.claudeCode.model;
+  let model;
+  try {
+    model = parseProviderModel(modelSpec);
+  } catch (err) {
+    return finish({ exitCode: 99, reason: `agent.model invalid: ${err instanceof Error ? err.message : String(err)}` });
+  }
+  let litellm = null;
+  try {
+    litellm = await startLitellmIfNeeded(model, input.cwd);
+  } catch (err) {
+    return finish({ exitCode: 99, reason: `litellm startup failed: ${err instanceof Error ? err.message : String(err)}` });
+  }
+  const ctx = {
+    args,
+    cwd: input.cwd,
+    config: input.config,
+    verbose: input.verbose,
+    quiet: input.quiet,
+    data: {},
+    output: { exitCode: 0 }
+  };
+  const ndjsonDir = path8.join(input.cwd, ".kody2");
+  const invokeAgent = async (prompt) => runAgent({
+    prompt,
+    model,
+    cwd: input.cwd,
+    litellmUrl: litellm?.url ?? null,
+    verbose: input.verbose,
+    quiet: input.quiet,
+    ndjsonDir,
+    allowedToolsOverride: profile.claudeCode.tools,
+    permissionModeOverride: profile.claudeCode.permissionMode
+  });
+  ctx.data.__invokeAgent = invokeAgent;
+  try {
+    for (const entry of profile.scripts.preflight) {
+      if (!shouldRun(entry, ctx)) continue;
+      const fn = preflightScripts[entry.script];
+      if (!fn) return finish({ exitCode: 99, reason: `preflight script not registered: ${entry.script}` });
+      await fn(ctx, profile);
+      if (ctx.skipAgent && ctx.output.exitCode !== void 0 && ctx.output.exitCode !== 0) {
+        return finish(ctx.output);
+      }
+    }
+    let agentResult = null;
+    if (!ctx.skipAgent) {
+      const prompt = ctx.data.prompt;
+      if (!prompt) {
+        return finish({ exitCode: 99, reason: "composePrompt did not produce a prompt (ctx.data.prompt missing)" });
+      }
+      agentResult = await invokeAgent(prompt);
+    }
+    for (const entry of profile.scripts.postflight) {
+      if (!shouldRun(entry, ctx)) continue;
+      const fn = postflightScripts[entry.script];
+      if (!fn) return finish({ exitCode: 99, reason: `postflight script not registered: ${entry.script}` });
+      await fn(ctx, profile, agentResult);
+    }
+    return finish(ctx.output);
+  } finally {
+    try {
+      litellm?.kill();
+    } catch {
+    }
+  }
+}
+function resolveProfilePath(profileName) {
+  const here = path8.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path8.join(here, "executables", profileName, "profile.json"),
+    // same-dir sibling (dev)
+    path8.join(here, "..", "executables", profileName, "profile.json"),
+    // up one (prod: dist/bin → dist/executables)
+    path8.join(here, "..", "src", "executables", profileName, "profile.json")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs9.existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+function validateInputs(specs, raw) {
+  const out = {};
+  for (const spec of specs) {
+    const v = raw[spec.name];
+    if (v === void 0 || v === null) continue;
+    out[spec.name] = coerce(spec, v);
+  }
+  for (const spec of specs) {
+    const present = out[spec.name] !== void 0;
+    if (present) continue;
+    const isRequired = spec.required === true || satisfiesRequiredWhen(spec.requiredWhen, out);
+    if (isRequired) {
+      throw new Error(`required input missing: ${spec.flag} (${spec.name})`);
+    }
+  }
+  return out;
+}
+function coerce(spec, v) {
+  switch (spec.type) {
+    case "int": {
+      const n = typeof v === "number" ? v : parseInt(String(v), 10);
+      if (Number.isNaN(n)) throw new Error(`${spec.flag} must be an integer`);
+      return n;
+    }
+    case "bool": {
+      if (typeof v === "boolean") return v;
+      const s = String(v).toLowerCase();
+      return s === "true" || s === "1" || s === "yes";
+    }
+    case "enum": {
+      const s = String(v);
+      if (!spec.values?.includes(s)) throw new Error(`${spec.flag} must be one of: ${spec.values?.join("|")}`);
+      return s;
+    }
+    default:
+      return String(v);
+  }
+}
+function satisfiesRequiredWhen(rw, current) {
+  if (!rw) return false;
+  for (const [key, want] of Object.entries(rw)) {
+    const actual = String(current[key] ?? "");
+    const wanted = Array.isArray(want) ? want.map(String) : [String(want)];
+    if (wanted.includes(actual)) return true;
+  }
+  return false;
+}
+function shouldRun(entry, ctx) {
+  if (!entry.runWhen) return true;
+  for (const [key, want] of Object.entries(entry.runWhen)) {
+    const actual = resolveDottedPath(ctx, key);
+    const wanted = Array.isArray(want) ? want : [want];
+    if (!wanted.map(String).includes(String(actual))) return false;
+  }
+  return true;
+}
+function resolveDottedPath(root, key) {
+  const parts = key.split(".");
+  let cur = root;
+  for (const p of parts) {
+    if (cur === null || cur === void 0) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function finish(out) {
+  if (out.prUrl) process.stdout.write(`PR_URL=${out.prUrl}
+`);
+  else if (out.reason) process.stdout.write(`PR_URL=FAILED: ${out.reason}
+`);
+  return out;
+}
+
+// src/kody2-cli.ts
+import * as fs10 from "fs";
+import * as path9 from "path";
+import { execFileSync as execFileSync11 } from "child_process";
+var CI_HELP = `kody2 ci \u2014 minimal-YAML autonomous engineer (CI preflight + run)
+
+Usage:
+  kody2 ci --issue <N> [--cwd <path>] [--verbose|--quiet]
+           [--skip-install] [--skip-litellm] [--package-manager pnpm|yarn|bun|npm]
+
+Options:
+  --issue <N>          GitHub issue number to work on (required)
+  --cwd <path>         Project directory (default: cwd)
+  --verbose            Print full tool output
+  --quiet              Print only errors and final PR_URL
+  --skip-install       Skip dependency install (pre-warmed runners)
+  --skip-litellm       Skip LiteLLM proxy install (Anthropic-direct)
+  --package-manager    Override package-manager auto-detect
+
+Environment:
+  ALL_SECRETS          JSON blob of all GitHub secrets (auto-populated in CI)
+  KODY_TOKEN|GH_TOKEN|GITHUB_TOKEN|GH_PAT   auth token for gh/git operations
+
+Exit codes (inherited from kody2 run):
+  0   success (PR opened, verify passed)
+  1   agent reported FAILED (draft PR opened)
+  2   verify failed (draft PR opened)
+  3   no commits to ship
+  4   PR creation failed
+  5   uncommitted changes on target branch
+  99  wrapper crashed
+`;
+function parseCiArgs(argv) {
+  const result = { errors: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--issue") {
+      const n = parseInt(argv[++i] ?? "", 10);
+      if (Number.isNaN(n) || n <= 0) result.errors.push("--issue requires a positive integer");
+      else result.issueNumber = n;
+    } else if (arg === "--cwd") {
+      result.cwd = argv[++i];
+    } else if (arg === "--verbose") result.verbose = true;
+    else if (arg === "--quiet") result.quiet = true;
+    else if (arg === "--skip-install") result.skipInstall = true;
+    else if (arg === "--skip-litellm") result.skipLitellm = true;
+    else if (arg === "--package-manager") {
+      const v = argv[++i];
+      if (v === "pnpm" || v === "yarn" || v === "bun" || v === "npm") result.packageManager = v;
+      else result.errors.push(`--package-manager must be one of pnpm|yarn|bun|npm (got: ${v})`);
+    } else if (arg === "--help" || arg === "-h") {
+      result.errors.push("__HELP__");
+    } else if (arg?.startsWith("--")) {
+      result.errors.push(`unknown arg: ${arg}`);
+    } else if (arg) {
+      result.errors.push(`unexpected positional: ${arg}`);
+    }
+  }
+  if (!result.issueNumber && !result.errors.includes("__HELP__")) {
+    result.errors.push("--issue <N> is required");
+  }
+  return result;
+}
+function unpackAllSecrets(env = process.env) {
+  const raw = env.ALL_SECRETS;
+  if (!raw) return 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return 0;
+  }
+  if (!parsed || typeof parsed !== "object") return 0;
+  let count = 0;
+  for (const [k, v] of Object.entries(parsed)) {
+    if (typeof v !== "string" || !v) continue;
+    if (env[k] !== void 0) continue;
+    env[k] = v;
+    count++;
+  }
+  return count;
+}
+function resolveAuthToken(env = process.env) {
+  const token = env.KODY_TOKEN || env.GH_TOKEN || env.GITHUB_TOKEN || env.GH_PAT;
+  if (token && !env.GH_TOKEN) env.GH_TOKEN = token;
+  return token;
+}
+function detectPackageManager(cwd) {
+  if (fs10.existsSync(path9.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs10.existsSync(path9.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs10.existsSync(path9.join(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+function shellOut(cmd, args, cwd, stream = true) {
+  try {
+    execFileSync11(cmd, args, {
+      cwd,
+      stdio: stream ? "inherit" : "pipe",
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
+    });
+    return 0;
+  } catch (err) {
+    const e = err;
+    return e.status ?? 1;
+  }
+}
+function isOnPath(bin) {
+  try {
+    execFileSync11("which", [bin], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensurePackageManagerInstalled(pm, cwd) {
+  if (pm === "npm" || isOnPath(pm)) return 0;
+  process.stdout.write(`\u2192 kody2: ${pm} not on PATH \u2014 installing via npm install -g ${pm}
+`);
+  return shellOut("npm", ["install", "-g", pm], cwd);
+}
+function installDeps(pm, cwd) {
+  const ensureCode = ensurePackageManagerInstalled(pm, cwd);
+  if (ensureCode !== 0) return ensureCode;
+  const args = {
+    pnpm: ["install", "--frozen-lockfile"],
+    yarn: ["install", "--frozen-lockfile"],
+    bun: ["install", "--frozen-lockfile"],
+    npm: ["ci"]
+  };
+  return shellOut(pm, args[pm], cwd);
+}
+function installLitellmIfNeeded(cwd) {
+  try {
+    const cfg = loadConfig(cwd);
+    const model = parseProviderModel(cfg.agent.model);
+    if (!needsLitellmProxy(model)) {
+      process.stdout.write("\u2192 kody2: provider is anthropic/claude, skipping LiteLLM install\n");
+      return 0;
+    }
+  } catch {
+  }
+  try {
+    execFileSync11("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    process.stdout.write("\u2192 kody2: litellm already installed\n");
+    return 0;
+  } catch {
+  }
+  process.stdout.write("\u2192 kody2: installing litellm (pip install 'litellm[proxy]')\n");
+  return shellOut("pip", ["install", "litellm[proxy]"], cwd);
+}
+function configureGitIdentity(cwd) {
+  try {
+    const name = execFileSync11("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    if (name) return;
+  } catch {
+  }
+  try {
+    execFileSync11("git", ["config", "user.name", "kody2-bot"], { cwd, stdio: "pipe" });
+  } catch {
+  }
+  try {
+    execFileSync11("git", ["config", "user.email", "kody2-bot@users.noreply.github.com"], { cwd, stdio: "pipe" });
+  } catch {
+  }
+}
+function postFailureTail(issueNumber, cwd, reason) {
+  if (!issueNumber) return;
+  const logPath = path9.join(cwd, ".kody2", "last-run.jsonl");
+  let tail = "";
+  try {
+    if (fs10.existsSync(logPath)) {
+      const content = fs10.readFileSync(logPath, "utf-8");
+      tail = content.slice(-3e3);
+    }
+  } catch {
+  }
+  const body = tail ? `\u26A0\uFE0F kody2 preflight failed: ${truncate(reason, 500)}
+
+<details><summary>Last-run log tail</summary>
+
+\`\`\`
+${tail}
+\`\`\`
+
+</details>` : `\u26A0\uFE0F kody2 preflight failed: ${truncate(reason, 1500)}`;
+  try {
+    postIssueComment(issueNumber, body, cwd);
+  } catch {
+  }
+}
+async function runCi(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(CI_HELP);
+    return 0;
+  }
+  const args = parseCiArgs(argv);
+  if (args.errors.length > 0 && !args.errors.includes("__HELP__")) {
+    for (const e of args.errors) process.stderr.write(`error: ${e}
+`);
+    process.stderr.write("\n" + CI_HELP);
+    return 64;
+  }
+  const cwd = args.cwd ? path9.resolve(args.cwd) : process.cwd();
+  const issueNumber = args.issueNumber;
+  process.stdout.write(`\u2192 kody2 preflight (cwd=${cwd}, issue=${issueNumber})
+`);
+  try {
+    const n = unpackAllSecrets();
+    if (n > 0) process.stdout.write(`\u2192 kody2: unpacked ${n} secret(s) from ALL_SECRETS
+`);
+    resolveAuthToken();
+    reactToTriggerComment(cwd);
+    const pm = args.packageManager ?? detectPackageManager(cwd);
+    process.stdout.write(`\u2192 kody2: package manager = ${pm}
+`);
+    if (!args.skipInstall) {
+      const code = installDeps(pm, cwd);
+      if (code !== 0) {
+        postFailureTail(issueNumber, cwd, `dependency install failed (${pm}, exit ${code})`);
+        return 99;
+      }
+    } else {
+      process.stdout.write("\u2192 kody2: skipping dep install (--skip-install)\n");
+    }
+    if (!args.skipLitellm) {
+      const code = installLitellmIfNeeded(cwd);
+      if (code !== 0) {
+        postFailureTail(issueNumber, cwd, `litellm install failed (exit ${code})`);
+        return 99;
+      }
+    } else {
+      process.stdout.write("\u2192 kody2: skipping LiteLLM install (--skip-litellm)\n");
+    }
+    configureGitIdentity(cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody2] preflight crashed: ${msg}
+`);
+    postFailureTail(issueNumber, cwd, `preflight crashed: ${msg}`);
+    return 99;
+  }
+  process.stdout.write("\u2192 kody2: preflight done, handing off to kody2 run\n\n");
+  try {
+    const config = loadConfig(cwd);
+    const result = await runExecutable("build", {
+      cliArgs: { mode: "run", issue: issueNumber },
+      cwd,
+      config,
+      verbose: args.verbose,
+      quiet: args.quiet
+    });
+    if (result.exitCode !== 0 && result.exitCode !== 1 && result.exitCode !== 2) {
+      postFailureTail(issueNumber, cwd, result.reason || `exit ${result.exitCode}`);
+    }
+    return result.exitCode;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody2] run crashed: ${msg}
+`);
+    if (err instanceof Error && err.stack) process.stderr.write(err.stack + "\n");
+    postFailureTail(issueNumber, cwd, `run crashed: ${msg}`);
+    return 99;
+  }
+}
+
+// src/entry.ts
+var HELP_TEXT = `kody2 \u2014 single-session autonomous engineer
+
+Usage:
+  kody2 run     --issue <N> [--cwd <path>] [--verbose|--quiet] [--dry-run]
+  kody2 ci      --issue <N> [preflight flags \u2014 see: kody2 ci --help]
+  kody2 fix     --pr    <N> [--feedback "..."] [--cwd <path>] [--verbose|--quiet]
+  kody2 fix-ci  --pr    <N> [--run-id <ID>]    [--cwd <path>] [--verbose|--quiet]
+  kody2 resolve --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
+  kody2 help
+  kody2 version
+
+All commands dispatch to the Build executable with a specific mode. The
+executable is defined by \`src/executables/build/profile.json\`.
+
+Exit codes:
+  0   success (PR opened, verify passed)
+  1   agent reported FAILED (draft PR opened)
+  2   verify failed (draft PR opened)
+  3   no commits to ship
+  4   PR creation failed
+  5   uncommitted changes on target branch
+  64  invalid CLI args
+  99  wrapper crashed
+`;
+function parseArgs(argv) {
+  const result = { command: "help", errors: [] };
+  if (argv.length === 0) return result;
+  const cmd = argv[0];
+  if (cmd === "help" || cmd === "--help" || cmd === "-h") return { ...result, command: "help" };
+  if (cmd === "version" || cmd === "--version" || cmd === "-v") return { ...result, command: "version" };
+  if (cmd === "ci") {
+    return { ...result, command: "ci", ciArgv: argv.slice(1) };
+  }
+  if (cmd === "run" || cmd === "fix" || cmd === "fix-ci" || cmd === "resolve") {
+    result.command = cmd;
+    parseCommandArgs(cmd, argv.slice(1), result);
+    return result;
+  }
+  result.errors.push(`unknown command: ${cmd}`);
+  return result;
+}
+function parseCommandArgs(cmd, rest, result) {
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--issue") {
+      const n = parseInt(rest[++i] ?? "", 10);
+      if (Number.isNaN(n) || n <= 0) result.errors.push("--issue requires a positive integer");
+      else result.issueNumber = n;
+    } else if (arg === "--pr") {
+      const n = parseInt(rest[++i] ?? "", 10);
+      if (Number.isNaN(n) || n <= 0) result.errors.push("--pr requires a positive integer");
+      else result.prNumber = n;
+    } else if (arg === "--feedback") {
+      result.feedback = rest[++i];
+    } else if (arg === "--run-id") {
+      result.runId = rest[++i];
+    } else if (arg === "--cwd") {
+      result.cwd = rest[++i];
+    } else if (arg === "--verbose") result.verbose = true;
+    else if (arg === "--quiet") result.quiet = true;
+    else if (arg === "--dry-run") result.dryRun = true;
+    else result.errors.push(`unknown arg: ${arg}`);
+  }
+  if (cmd === "run" && !result.issueNumber) result.errors.push("--issue <N> is required for run");
+  if (cmd === "fix" && !result.prNumber) result.errors.push("--pr <N> is required for fix");
+  if (cmd === "fix-ci" && !result.prNumber) result.errors.push("--pr <N> is required for fix-ci");
+  if (cmd === "resolve" && !result.prNumber) result.errors.push("--pr <N> is required for resolve");
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.errors.length > 0) {
+    for (const e of args.errors) process.stderr.write(`error: ${e}
+`);
+    process.stderr.write("\n" + HELP_TEXT);
+    return 64;
+  }
+  if (args.command === "help") {
+    process.stdout.write(HELP_TEXT);
+    return 0;
+  }
+  if (args.command === "version") {
+    process.stdout.write("kody2 0.2.0\n");
+    return 0;
+  }
+  if (args.command === "ci") {
+    try {
+      return await runCi(args.ciArgv ?? []);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody2] fatal: ${msg}
+`);
+      if (err instanceof Error && err.stack) process.stderr.write(err.stack + "\n");
+      return 99;
+    }
+  }
+  const cwd = args.cwd ?? process.cwd();
+  let config;
+  try {
+    config = loadConfig(cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody2] config error: ${msg}
+`);
+    process.stdout.write(`PR_URL=FAILED: config error: ${msg}
+`);
+    return 99;
+  }
+  const cliArgs = { mode: args.command };
+  if (args.issueNumber !== void 0) cliArgs.issue = args.issueNumber;
+  if (args.prNumber !== void 0) cliArgs.pr = args.prNumber;
+  if (args.feedback !== void 0) cliArgs.feedback = args.feedback;
+  if (args.runId !== void 0) cliArgs.runId = args.runId;
+  try {
+    const result = await runExecutable("build", {
+      cliArgs,
+      cwd,
+      config,
+      verbose: args.verbose,
+      quiet: args.quiet
+    });
+    return result.exitCode;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody2] wrapper crashed: ${msg}
+`);
+    if (err instanceof Error && err.stack) process.stderr.write(err.stack + "\n");
+    process.stdout.write(`PR_URL=FAILED: wrapper crashed: ${msg}
+`);
+    return 99;
+  }
+}
+
+// bin/kody2.ts
+main().then((code) => {
+  process.exit(code);
+}).catch((err) => {
+  process.stderr.write(`[kody2] fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(99);
+});