@kody-ade/kody-engine 0.4.278 → 0.4.280

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.278",
+      version: "0.4.280",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -147,11 +147,11 @@ var init_claudeBinary = __esm({
 // src/issue.ts
 import { execFileSync } from "child_process";
 function ghToken(preferRepoToken = false) {
-  const githubToken = process.env.GITHUB_TOKEN?.trim();
+  const githubToken2 = process.env.GITHUB_TOKEN?.trim();
   const kodyToken = process.env.KODY_TOKEN?.trim();
   const ghToken3 = process.env.GH_TOKEN?.trim();
   const ghPat = process.env.GH_PAT?.trim();
-  return preferRepoToken ? githubToken || kodyToken || ghToken3 || ghPat : ghPat || ghToken3 || kodyToken || githubToken;
+  return preferRepoToken ? githubToken2 || kodyToken || ghToken3 || ghPat : ghPat || ghToken3 || kodyToken || githubToken2;
 }
 function gh(args, options) {
   const token = ghToken(options?.preferRepoToken);
@@ -532,11 +532,11 @@ function branchApiPath(config, targetPath) {
 }
 function ensureStateBranch(config, cwd) {
   const parsed = parseStateRepo(config);
-  const cacheKey2 = `${parsed.owner}/${parsed.repo}:${STATE_BRANCH}`;
-  if (ensuredStateBranches.has(cacheKey2)) return;
+  const cacheKey3 = `${parsed.owner}/${parsed.repo}:${STATE_BRANCH}`;
+  if (ensuredStateBranches.has(cacheKey3)) return;
   try {
     gh(["api", `/repos/${parsed.owner}/${parsed.repo}/git/ref/heads/${STATE_BRANCH}`], { cwd });
-    ensuredStateBranches.add(cacheKey2);
+    ensuredStateBranches.add(cacheKey3);
     return;
   } catch (err) {
     if (!is404(err)) throw err;
@@ -555,7 +555,7 @@ function ensureStateBranch(config, cwd) {
   } catch (err) {
     if (!isAlreadyExists(err)) throw err;
   }
-  ensuredStateBranches.add(cacheKey2);
+  ensuredStateBranches.add(cacheKey3);
 }
 function readStateText(config, cwd, filePath) {
   const targetPath = stateRepoPath(config, filePath);
@@ -1208,7 +1208,7 @@ var init_events = __esm({
 // src/verify.ts
 import { spawn } from "child_process";
 function runCommand(command, cwd) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const start = Date.now();
     const child = spawn(command, {
       cwd,
@@ -1237,11 +1237,11 @@ function runCommand(command, cwd) {
     child.on("exit", (code) => {
       clearTimeout(timer);
       const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve8({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      resolve9({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve8({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      resolve9({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
     });
   });
 }
@@ -2884,7 +2884,7 @@ var init_repoWorkspace = __esm({
     defaultCloneRepo = (repo, token, dir) => {
       fs7.mkdirSync(path9.dirname(dir), { recursive: true });
       const authUrl = token ? `https://x-access-token:${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         const child = spawn2("git", ["clone", "--depth=1", authUrl, dir], {
           stdio: "inherit"
         });
@@ -2900,7 +2900,7 @@ var init_repoWorkspace = __esm({
             spawnSync("git", ["-C", dir, "config", "user.email", email]);
           } catch {
           }
-          resolve8();
+          resolve9();
         });
         child.on("error", reject);
       });
@@ -3208,10 +3208,10 @@ async function runAgent(opts) {
         let timer;
         let next;
         if (turnTimeoutMs > 0) {
-          const timeoutPromise = new Promise((resolve8) => {
+          const timeoutPromise = new Promise((resolve9) => {
             timer = setTimeout(() => {
               timedOut = true;
-              resolve8({ done: true, value: void 0 });
+              resolve9({ done: true, value: void 0 });
             }, turnTimeoutMs);
           });
           next = await Promise.race([nextPromise, timeoutPromise]);
@@ -12415,11 +12415,6 @@ on:
         required: false
         type: string
         default: ""
-      executable:
-        description: "Legacy alias for capability action"
-        required: false
-        type: string
-        default: ""
   issue_comment:
     types: [created]
 
@@ -12658,7 +12653,7 @@ function retryDelaysMs() {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 async function fetchGoalStateWithRetry(config, goalId, cwd) {
   let state = fetchGoalState(config, goalId, cwd);
@@ -15326,7 +15321,7 @@ var init_previewBuildHelpers = __esm({
 // src/scripts/previewBuildRun.ts
 import { spawn as spawn4 } from "child_process";
 async function runCmd(cmd, args, opts = {}) {
-  await new Promise((resolve8, reject) => {
+  await new Promise((resolve9, reject) => {
     const child = spawn4(cmd, args, {
       cwd: opts.cwd,
       env: { ...process.env, ...opts.env ?? {} },
@@ -15338,7 +15333,7 @@ async function runCmd(cmd, args, opts = {}) {
     }
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve8();
+      if (code === 0) resolve9();
       else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}`));
     });
   });
@@ -16462,7 +16457,7 @@ function stripAnsi2(s) {
   return s.replace(ANSI_RE2, "");
 }
 function runCommand2(command, cwd) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const child = spawn5(command, {
       cwd,
       shell: true,
@@ -16489,11 +16484,11 @@ function runCommand2(command, cwd) {
     }, TEST_TIMEOUT_MS);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve8({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
+      resolve9({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve8({ exitCode: -1, output: err.message });
+      resolve9({ exitCode: -1, output: err.message });
     });
   });
 }
@@ -16898,21 +16893,21 @@ function lineStream(stream) {
     tryDeliver();
   });
   return {
-    next: (timeoutMs) => new Promise((resolve8) => {
+    next: (timeoutMs) => new Promise((resolve9) => {
       if (queue.length > 0) {
-        resolve8(queue.shift());
+        resolve9(queue.shift());
         return;
       }
       if (ended) {
-        resolve8(null);
+        resolve9(null);
         return;
       }
-      waiter = resolve8;
+      waiter = resolve9;
       const t = setTimeout(
         () => {
-          if (waiter === resolve8) {
+          if (waiter === resolve9) {
             waiter = null;
-            resolve8(null);
+            resolve9(null);
           }
         },
         Math.max(0, timeoutMs)
@@ -17295,42 +17290,111 @@ var init_scripts = __esm({
 });
 
 // src/stateWorkspace.ts
+import { execFileSync as execFileSync24 } from "child_process";
+import * as crypto3 from "crypto";
 import * as fs43 from "fs";
+import * as os7 from "os";
 import * as path41 from "path";
 function writeLocalFile(cwd, relativePath, content) {
   const fullPath = path41.join(cwd, relativePath);
   fs43.mkdirSync(path41.dirname(fullPath), { recursive: true });
   fs43.writeFileSync(fullPath, content);
 }
-function hydrateDirectory(config, cwd, stateDir, localDir) {
-  const entries = listStateDirectory(config, cwd, stateDir);
-  if (entries.length === 0) return;
-  for (const entry of entries) {
-    if (!entry.name || !entry.type) continue;
-    const childState = path41.posix.join(stateDir, entry.name);
-    const childLocal = path41.join(localDir, entry.name);
-    if (entry.type === "dir") {
-      fs43.rmSync(path41.join(cwd, childLocal), { recursive: true, force: true });
-      hydrateDirectory(config, cwd, childState, childLocal);
-    } else if (entry.type === "file") {
-      const file = readStateText(config, cwd, childState);
-      if (file) writeLocalFile(cwd, childLocal, file.content);
-    }
+function copyPath(source, target) {
+  const st = fs43.lstatSync(source);
+  fs43.rmSync(target, { recursive: true, force: true });
+  if (st.isSymbolicLink()) return;
+  fs43.mkdirSync(path41.dirname(target), { recursive: true });
+  fs43.cpSync(source, target, { recursive: true, force: true });
+}
+function overlayDirectoryChildren(cwd, sourceDir, localDir) {
+  if (!fs43.existsSync(sourceDir)) return;
+  for (const entry of fs43.readdirSync(sourceDir, { withFileTypes: true })) {
+    const source = path41.join(sourceDir, entry.name);
+    const target = path41.join(cwd, localDir, entry.name);
+    copyPath(source, target);
   }
 }
 function hydrateStateWorkspace(config, cwd) {
+  if (process.env.VITEST && process.env[TEST_FETCH_ENV] !== "1") return;
+  const parsed = parseStateRepo(config);
+  const hydrateKey = `${path41.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${STATE_BRANCH}`;
+  if (hydratedWorkspaces.has(hydrateKey)) return;
+  const snapshotRoot = fetchStateSnapshot(parsed);
   for (const mapping of DIR_MAPPINGS) {
-    hydrateDirectory(config, cwd, mapping.stateDir, mapping.localDir);
+    overlayDirectoryChildren(cwd, path41.join(snapshotRoot, mapping.stateDir), mapping.localDir);
   }
   for (const mapping of FILE_MAPPINGS) {
-    const file = readStateText(config, cwd, mapping.statePath);
-    if (file) writeLocalFile(cwd, mapping.localPath, file.content);
+    const source = path41.join(snapshotRoot, mapping.statePath);
+    if (fs43.existsSync(source) && !fs43.lstatSync(source).isSymbolicLink() && fs43.statSync(source).isFile()) {
+      writeLocalFile(cwd, mapping.localPath, fs43.readFileSync(source, "utf-8"));
+    }
+  }
+  hydratedWorkspaces.add(hydrateKey);
+}
+function fetchStateSnapshot(parsed) {
+  const cacheDir = path41.join(cacheRoot2(), cacheKey2(parsed));
+  const url = `https://github.com/${parsed.owner}/${parsed.repo}.git`;
+  try {
+    fs43.mkdirSync(path41.dirname(cacheDir), { recursive: true });
+    if (!fs43.existsSync(path41.join(cacheDir, ".git"))) {
+      fs43.rmSync(cacheDir, { recursive: true, force: true });
+      runGit3(["clone", "--no-checkout", "--filter=blob:none", url, cacheDir]);
+    }
+    runGit3(["-C", cacheDir, "remote", "set-url", "origin", url]);
+    runGit3(["-C", cacheDir, "fetch", "--depth=1", "origin", STATE_BRANCH]);
+    runGit3(["-C", cacheDir, "sparse-checkout", "init", "--cone"]);
+    runGit3(["-C", cacheDir, "sparse-checkout", "set", parsed.basePath]);
+    runGit3(["-C", cacheDir, "checkout", "--force", "--detach", "FETCH_HEAD"]);
+    runGit3(["-C", cacheDir, "clean", "-fdx"]);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${STATE_BRANCH}: ${msg}`
+    );
+  }
+  return path41.join(cacheDir, parsed.basePath);
+}
+function cacheRoot2() {
+  return process.env[CACHE_ENV2]?.trim() || path41.join(os7.homedir(), ".cache", "kody", "state-repo");
+}
+function cacheKey2(parsed) {
+  return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${STATE_BRANCH}#${parsed.basePath}`).digest("hex").slice(0, 24);
+}
+function runGit3(args) {
+  try {
+    execFileSync24("git", args, {
+      encoding: "utf-8",
+      env: githubAuthEnv(),
+      stdio: ["ignore", "ignore", "pipe"],
+      timeout: 12e4
+    });
+  } catch (err) {
+    const stderr = err.stderr;
+    const detail = Buffer.isBuffer(stderr) ? stderr.toString("utf-8").trim() : typeof stderr === "string" ? stderr.trim() : "";
+    throw new Error(detail || `git ${args[0] ?? "command"} failed`);
   }
 }
-var DIR_MAPPINGS, FILE_MAPPINGS;
+function githubAuthEnv() {
+  const token = githubToken();
+  if (!token) return process.env;
+  const encoded = Buffer.from(`x-access-token:${token}`).toString("base64");
+  const existingCount = /^\d+$/.test(process.env.GIT_CONFIG_COUNT ?? "") ? Number(process.env.GIT_CONFIG_COUNT) : 0;
+  return {
+    ...process.env,
+    GIT_CONFIG_COUNT: String(existingCount + 1),
+    [`GIT_CONFIG_KEY_${existingCount}`]: "http.https://github.com/.extraheader",
+    [`GIT_CONFIG_VALUE_${existingCount}`]: `AUTHORIZATION: basic ${encoded}`
+  };
+}
+function githubToken() {
+  return process.env.KODY_TOKEN?.trim() || process.env.GH_TOKEN?.trim() || process.env.GITHUB_TOKEN?.trim() || process.env.GH_PAT?.trim() || void 0;
+}
+var DIR_MAPPINGS, FILE_MAPPINGS, CACHE_ENV2, TEST_FETCH_ENV, hydratedWorkspaces;
 var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
+    init_stateBranch();
     init_stateRepo();
     DIR_MAPPINGS = [
       { stateDir: "executables", localDir: path41.join(".kody", "executables") },
@@ -17344,11 +17408,14 @@ var init_stateWorkspace = __esm({
       { statePath: "variables.json", localPath: path41.join(".kody", "variables.json") },
       { statePath: "secrets.enc", localPath: path41.join(".kody", "secrets.enc") }
     ];
+    CACHE_ENV2 = "KODY_STATE_REPO_CACHE";
+    TEST_FETCH_ENV = "KODY_STATE_WORKSPACE_FETCH_FOR_TESTS";
+    hydratedWorkspaces = /* @__PURE__ */ new Set();
   }
 });
 
 // src/tools.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -17385,7 +17452,7 @@ function verifyOne(tool6, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    const stdout = execFileSync24("sh", ["-c", cmd], {
+    const stdout = execFileSync25("sh", ["-c", cmd], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: timeoutMs,
@@ -18131,14 +18198,14 @@ async function runShellEntry(entry, ctx, profile) {
   let killTimer;
   let escalateTimer;
   const result = await new Promise(
-    (resolve8) => {
+    (resolve9) => {
       let settled = false;
       const settle = (code, signal, spawnErr) => {
         if (settled) return;
         settled = true;
         if (killTimer) clearTimeout(killTimer);
         if (escalateTimer) clearTimeout(escalateTimer);
-        resolve8({ code, signal, spawnErr });
+        resolve9({ code, signal, spawnErr });
       };
       child.on("error", (err) => settle(null, null, err));
       child.on("close", (code, signal) => settle(code, signal));
@@ -19377,7 +19444,7 @@ _\u2026 (instructions truncated)_` : trimmed;
 init_config();
 
 // src/kody-cli.ts
-import { execFileSync as execFileSync25 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 import * as fs46 from "fs";
 import * as path45 from "path";
 
@@ -20034,7 +20101,7 @@ function recoverCheckoutToken(env = process.env, cwd = process.cwd()) {
   if (env.GITHUB_TOKEN?.trim()) return env.GITHUB_TOKEN.trim();
   let header = "";
   try {
-    header = execFileSync25("git", ["config", "--local", "--get", "http.https://github.com/.extraheader"], {
+    header = execFileSync26("git", ["config", "--local", "--get", "http.https://github.com/.extraheader"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -20096,7 +20163,7 @@ function shouldChainScheduledWatch(match) {
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync25(cmd, args, {
+    execFileSync26(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -20109,7 +20176,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync25("which", [bin], { stdio: "pipe" });
+    execFileSync26("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -20150,7 +20217,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync25("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync26("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -20160,16 +20227,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync25("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync26("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync25("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync26("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync25("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync26("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -20779,17 +20846,17 @@ function authOk(req, expected) {
   return false;
 }
 function readJsonBody(req) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve8({});
+        resolve9({});
         return;
       }
       try {
-        resolve8(JSON.parse(raw));
+        resolve9(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -21141,11 +21208,11 @@ async function brainServe(opts) {
     model,
     litellmUrl
   });
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     server.listen(port, "0.0.0.0", () => {
       process.stdout.write(`[brain-serve] listening on 0.0.0.0:${port} (cwd=${opts.cwd})
 `);
-      resolve8();
+      resolve9();
     });
   });
   const shutdown = (signal) => {
@@ -21398,14 +21465,14 @@ async function startBrainProxy(opts) {
   const { httpServer, handler } = buildBrainProxy(opts);
   const port = opts.port ?? 0;
   const host = opts.host ?? "127.0.0.1";
-  await new Promise((resolve8) => httpServer.listen(port, host, () => resolve8()));
+  await new Promise((resolve9) => httpServer.listen(port, host, () => resolve9()));
   const addr = httpServer.address();
   return {
     httpServer,
     port: addr.port,
     url: `http://${host}:${addr.port}`,
-    stop: () => new Promise((resolve8) => {
-      httpServer.close(() => resolve8());
+    stop: () => new Promise((resolve9) => {
+      httpServer.close(() => resolve9());
     }),
     handler
   };
@@ -21555,23 +21622,23 @@ function buildMcpHttpServer(opts) {
     httpServer,
     routes,
     port,
-    stop: () => new Promise((resolve8) => {
+    stop: () => new Promise((resolve9) => {
       let pending = transports.size;
       if (pending === 0) {
-        httpServer.close(() => resolve8());
+        httpServer.close(() => resolve9());
         return;
       }
       for (const transport of transports.values()) {
         void transport.close().finally(() => {
           pending--;
-          if (pending === 0) httpServer.close(() => resolve8());
+          if (pending === 0) httpServer.close(() => resolve9());
         });
       }
     })
   };
 }
 function listenMcpHttpServer(server, host = "127.0.0.1") {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     server.httpServer.once("error", reject);
     server.httpServer.listen(server.port, host, () => {
       server.httpServer.off("error", reject);
@@ -21579,7 +21646,7 @@ function listenMcpHttpServer(server, host = "127.0.0.1") {
       if (addr && typeof addr === "object") {
         server.port = addr.port;
       }
-      resolve8();
+      resolve9();
     });
   });
 }
@@ -21668,7 +21735,7 @@ import * as fs50 from "fs";
 import * as path49 from "path";
 
 // src/chat/inbox.ts
-import { execFileSync as execFileSync26 } from "child_process";
+import { execFileSync as execFileSync27 } from "child_process";
 var DEFAULT_POLL_MS = 3e3;
 async function waitForNextUserMessage(opts) {
   const pollMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
@@ -21692,13 +21759,13 @@ async function waitForNextUserMessage(opts) {
       try {
         const branch = currentBranch(opts.cwd);
         if (branch) {
-          execFileSync26("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
-          execFileSync26("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
+          execFileSync27("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync27("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
             cwd: opts.cwd,
             stdio: "pipe"
           });
         } else {
-          execFileSync26("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync27("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -21720,11 +21787,11 @@ async function waitForNextUserMessage(opts) {
   }
 }
 function sleep3(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 function currentBranch(cwd) {
   try {
-    const out = execFileSync26("git", ["symbolic-ref", "--short", "HEAD"], {
+    const out = execFileSync27("git", ["symbolic-ref", "--short", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -22823,14 +22890,14 @@ function sendJson2(res, status, body) {
   res.end(JSON.stringify(body));
 }
 function readJsonBody2(req) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw.trim()) return resolve8({});
+      if (!raw.trim()) return resolve9({});
       try {
-        resolve8(JSON.parse(raw));
+        resolve9(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -22921,8 +22988,8 @@ function synthesizeLegacyClaimRequest(input) {
 async function poolServe() {
   const masterRaw = process.env.KODY_MASTER_KEY?.trim();
   if (!masterRaw) throw new Error("KODY_MASTER_KEY required for pool-serve");
-  const githubToken = process.env.GITHUB_TOKEN?.trim();
-  if (!githubToken) throw new Error("GITHUB_TOKEN required for pool-serve (reads per-repo vaults)");
+  const githubToken2 = process.env.GITHUB_TOKEN?.trim();
+  if (!githubToken2) throw new Error("GITHUB_TOKEN required for pool-serve (reads per-repo vaults)");
   const master = masterKeyBytes(masterRaw);
   const poolApiKey = derivePoolApiKey(master);
   const runnerApiKey = deriveRunnerApiKey(master);
@@ -22935,7 +23002,7 @@ async function poolServe() {
   const apiPort = envInt2("POOL_API_PORT", 4100);
   const healthTimeoutMs = envInt2("POOL_HEALTH_TIMEOUT_MS", 12e4);
   const registry = new PoolRegistry({
-    githubToken,
+    githubToken: githubToken2,
     masterKey: master,
     base: {
       min,
@@ -23012,10 +23079,10 @@ async function poolServe() {
     }
   });
   const apiHost = process.env.POOL_API_HOST ?? "::";
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     server.listen(apiPort, apiHost, () => {
       log(`listening on ${apiHost}:${apiPort} (min=${min}, app=${app}, region=${region})`);
-      resolve8();
+      resolve9();
     });
   });
   const shutdown = (signal) => {
@@ -23054,17 +23121,17 @@ function authOk2(req, expected) {
   return false;
 }
 function readJsonBody3(req) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve8({});
+        resolve9({});
         return;
       }
       try {
-        resolve8(JSON.parse(raw));
+        resolve9(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -23083,8 +23150,8 @@ function parseJob(body) {
   if (!jobId) return { error: "jobId required" };
   const repo = typeof b.repo === "string" ? b.repo.trim() : "";
   if (!/^[^/\s]+\/[^/\s]+$/.test(repo)) return { error: "repo must be 'owner/name'" };
-  const githubToken = typeof b.githubToken === "string" ? b.githubToken.trim() : "";
-  if (!githubToken) return { error: "githubToken required" };
+  const githubToken2 = typeof b.githubToken === "string" ? b.githubToken.trim() : "";
+  if (!githubToken2) return { error: "githubToken required" };
   const action = typeof b.action === "string" && b.action.trim() ? b.action.trim() : void 0;
   const message = typeof b.message === "string" && b.message.trim() ? b.message.trim() : void 0;
   const mode = b.mode === "interactive" ? "interactive" : b.mode === "scheduled" ? "scheduled" : "issue";
@@ -23096,7 +23163,7 @@ function parseJob(body) {
     message
   });
   if ("error" in runRequest) return { error: runRequest.error };
-  const job = { jobId, repo, githubToken, runRequest: runRequest.request };
+  const job = { jobId, repo, githubToken: githubToken2, runRequest: runRequest.request };
   if (job.runRequest.target.type === "issue") {
     job.issueNumber = job.runRequest.target.id;
   } else if (job.runRequest.target.type === "chat") {
@@ -23198,13 +23265,13 @@ async function defaultRunJob(job) {
     ...interactive && job.idleExitMs ? { KODY_IDLE_EXIT_MS: String(job.idleExitMs) } : {},
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
-  const run = (cmd, args, cwd) => new Promise((resolve8) => {
+  const run = (cmd, args, cwd) => new Promise((resolve9) => {
     const child = spawn8(cmd, args, { stdio: "inherit", env: childEnv, cwd });
-    child.on("exit", (code) => resolve8(code ?? 0));
+    child.on("exit", (code) => resolve9(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`[runner-serve] ${cmd} failed: ${err.message}
 `);
-      resolve8(1);
+      resolve9(1);
     });
   });
   process.stdout.write(`[runner-serve] job ${job.jobId}: cloning ${job.repo}@${branch}
@@ -23280,11 +23347,11 @@ async function runnerServe() {
   const port = Number(process.env.PORT ?? DEFAULT_PORT2);
   const server = buildServer2({ apiKey });
   const host = process.env.RUNNER_HOST ?? "::";
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     server.listen(port, host, () => {
       process.stdout.write(`[runner-serve] listening on ${host}:${port} (idle, awaiting job)
 `);
-      resolve8();
+      resolve9();
     });
   });
   const shutdown = (signal) => {
@@ -23353,14 +23420,14 @@ async function serve(opts) {
 `);
     const args = ["--dangerously-skip-permissions", "--model", model.model];
     const child = spawn9("claude", args, { stdio: "inherit", env: editorEnv, cwd: opts.cwd });
-    const exitCode = await new Promise((resolve8) => {
-      child.on("exit", (code) => resolve8(code ?? 0));
+    const exitCode = await new Promise((resolve9) => {
+      child.on("exit", (code) => resolve9(code ?? 0));
       child.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch Claude Code: ${err.message}
 `);
         process.stderr.write(`  Install: https://docs.anthropic.com/claude/docs/claude-code
 `);
-        resolve8(1);
+        resolve9(1);
       });
     });
     killProxy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.278",
+  "version": "0.4.280",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,27 @@
     "templates",
     "kody.config.schema.json"
   ],
+  "scripts": {
+    "kody:run": "tsx bin/kody.ts",
+    "serve": "tsx bin/kody.ts serve",
+    "serve:vscode": "tsx bin/kody.ts serve vscode",
+    "serve:claude": "tsx bin/kody.ts serve claude",
+    "clean:dist": "node scripts/clean-dist.cjs",
+    "build": "pnpm clean:dist && tsup && node scripts/copy-assets.cjs",
+    "check:modularity": "tsx scripts/check-script-modularity.ts",
+    "pretest": "pnpm check:modularity",
+    "test": "vitest run tests/unit tests/int --coverage",
+    "posttest": "tsx scripts/check-coverage-floor.ts",
+    "test:smoke": "vitest run tests/smoke --no-coverage",
+    "test:e2e": "vitest run tests/e2e --no-coverage",
+    "test:all": "vitest run tests --no-coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write",
+    "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner",
+    "prepublishOnly": "pnpm typecheck && vitest run tests/unit tests/int --no-coverage && pnpm build"
+  },
   "dependencies": {
     "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119",
@@ -35,25 +56,5 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
-  "scripts": {
-    "kody:run": "tsx bin/kody.ts",
-    "serve": "tsx bin/kody.ts serve",
-    "serve:vscode": "tsx bin/kody.ts serve vscode",
-    "serve:claude": "tsx bin/kody.ts serve claude",
-    "clean:dist": "node scripts/clean-dist.cjs",
-    "build": "pnpm clean:dist && tsup && node scripts/copy-assets.cjs",
-    "check:modularity": "tsx scripts/check-script-modularity.ts",
-    "pretest": "pnpm check:modularity",
-    "test": "vitest run tests/unit tests/int --coverage",
-    "posttest": "tsx scripts/check-coverage-floor.ts",
-    "test:smoke": "vitest run tests/smoke --no-coverage",
-    "test:e2e": "vitest run tests/e2e --no-coverage",
-    "test:all": "vitest run tests --no-coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "format": "biome format --write",
-    "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner"
-  }
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
+}